laafeer
laafeer

大创项目推荐 题目：基于机器视觉opencv的手势检测 手势识别 算法 - 深度学习 卷积神经网络 opencv python

文章目录

  • 1 简介
  • 2 传统机器视觉的手势检测
    • 2.1 轮廓检测法
    • 2.2 算法结果
    • 2.3 整体代码实现
      • 2.3.1 算法流程
  • 3 深度学习方法做手势识别
    • 3.1 经典的卷积神经网络
    • 3.2 YOLO系列
    • 3.3 SSD
    • 3.4 实现步骤
      • 3.4.1 数据集
      • 3.4.2 图像预处理
      • 3.4.3 构建卷积神经网络结构
      • 3.4.4 实验训练过程及结果
    • 3.5 关键代码
  • 4 最后

1 简介

优质竞赛项目系列，今天要分享的是

基于机器视觉opencv的手势检测 手势识别 算法

该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！

更多资料, 项目分享：

https://gitee.com/dancheng-senior/postgraduate

2 传统机器视觉的手势检测

普通机器视觉手势检测的基本流程如下：

在这里插入图片描述
其中轮廓的提取，多边形拟合曲线的求法，凸包集和凹陷集的求法都是采用opencv中自带的函数。手势数字的识别是利用凸包点以及凹陷点和手部中心点的几何关系，简单的做了下逻辑判别了（可以肯定的是这种方法很烂），具体的做法是先在手部定位出2个中心点坐标，这2个中心点坐标之间的距离阈值由程序设定，其中一个中心点就是利用OpenNI跟踪得到的手部位置。有了这2个中心点的坐标，在程序中就可以分别计算出在这2个中心点坐标上的凸凹点的个数。当然了，这样做的前提是用人在做手势表示数字的同时应该是将手指的方向朝上（因为没有像机器学习那样通过样本来训练，所以使用时条件要苛刻很多）。利用上面求出的4种点的个数(另外程序中还设置了2个辅助计算点的个数，具体见代码部分)和简单的逻辑判断就可以识别出数字0~5了。其它的数字可以依照具体的逻辑去设计（还可以设计出多位数字的识别），只是数字越多设计起来越复杂，因为要考虑到它们之间的干扰性，且这种不通用的设计方法也没有太多的实际意义。

2.1 轮廓检测法

使用 void convexityDefects(InputArray contour, InputArray convexhull,
OutputArray convexityDefects) 方法

该函数的作用是对输入的轮廓contour，凸包集合来检测其轮廓的凸型缺陷，一个凸型缺陷结构体包括4个元素，缺陷起点坐标，缺陷终点坐标，缺陷中离凸包线距离最远的点的坐标，以及此时最远的距离。参数3即其输出的凸型缺陷结构体向量。

其凸型缺陷的示意图如下所示：

在这里插入图片描述
第1个参数虽然写的是contour，字面意思是轮廓，但是本人实验过很多次，发现如果该参数为目标通过轮廓检测得到的原始轮廓的话，则程序运行到onvexityDefects()函数时会报内存错误。因此本程序中采用的不是物体原始的轮廓，而是经过多项式曲线拟合后的轮廓，即多项式曲线，这样程序就会顺利地运行得很好。另外由于在手势识别过程中可能某一帧检测出来的轮廓非常小（由于某种原因），以致于少到只有1个点，这时候如果程序运行到onvexityDefects()函数时就会报如下的错误：

​

int Mat::checkVector(int _elemChannels, int _depth, bool _requireContinuous) const

{

    return (depth() == _depth || _depth <= 0) &&

        (isContinuous() || !_requireContinuous) &&

        ((dims == 2 && (((rows == 1 || cols == 1) && channels() == _elemChannels) || (cols == _elemChannels))) ||

        (dims == 3 && channels() == 1 && size.p[2] == _elemChannels && (size.p[0] == 1 || size.p[1] == 1) &&

         (isContinuous() || step.p[1] == step.p[2]*size.p[2])))

    ? (int)(total()*channels()/_elemChannels) : -1;

}

该函数源码大概意思就是说对应的Mat矩阵如果其深度，连续性，通道数，行列式满足一定条件的话就返回Mat元素的个数和其通道数的乘积，否则返回-1；而本文是要求其返回值大于3，有得知此处输入多边形曲线(即参数1)的通道数为2，所以还需要求其元素的个数大于1.5，即大于2才满足ptnum

3。简单的说就是用convexityDefects()函数来对多边形曲线进行凹陷检测时，必须要求参数1曲线本身至少有2个点(也不知道这样分析对不对)。因此本人在本次程序convexityDefects()函数前加入了if(Mat(approx_poly_curve).checkVector(2,
CV_32S) > 3)来判断，只有满足该if条件，才会进行后面的凹陷检测。这样程序就不会再出现类似的bug了。

第2个参数一般是由opencv中的函数convexHull()获得的，一般情况下该参数里面存的是凸包集合中的点在多项式曲线点中的位置索引，且该参数以vector的形式存在，因此参数convexhull中其元素的类型为unsigned
int。在本次凹陷点检测函数convexityDefects()里面根据文档，要求该参数为Mat型。因此在使用convexityDefects()的参数2时，一般将vector直接转换Mat型。

参数3是一个含有4个元素的结构体的集合，如果在c++的版本中，该参数可以直接用vector来代替，Vec4i中的4个元素分别表示凹陷曲线段的起始坐标索引，终点坐标索引，离凸包集曲线最远点的坐标索引以及此时的最远距离值，这4个值都是整数。在c版本的opencv中一般不是保存的索引，而是坐标值。

2.2 算法结果

数字“0”的识别结果：
在这里插入图片描述
数字“1”的识别结果

在这里插入图片描述

数字“2”的识别结果
在这里插入图片描述

数字“3”的识别结果：
在这里插入图片描述

数字“4”的识别结果：
在这里插入图片描述

数字“5”的识别结果：
在这里插入图片描述

2.3 整体代码实现

2.3.1 算法流程

学长实现过程和上面的系统流程图类似，大概过程如下：

  • 1. 求出手部的掩膜

  • 2. 求出掩膜的轮廓

  • 3. 求出轮廓的多变形拟合曲线

  • 4. 求出多边形拟合曲线的凸包集，找出凸点

  • 5. 求出多变形拟合曲线的凹陷集，找出凹点

  • 6. 利用上面的凸凹点和手部中心点的几何关系来做简单的数字手势识别

(这里用的是C语言写的，这个代码是学长早期写的，同学们需要的话，学长出一个python版本的)

​



    #include 
    
    #include "opencv2/highgui/highgui.hpp"
    #include "opencv2/imgproc/imgproc.hpp"
    #include 
    #include "copenni.cpp"
    
    #include 
    
    #define DEPTH_SCALE_FACTOR 255./4096.
    #define ROI_HAND_WIDTH 140
    #define ROI_HAND_HEIGHT 140
    #define MEDIAN_BLUR_K 5
    #define XRES  640
    #define YRES  480
    #define DEPTH_SEGMENT_THRESH 5
    #define MAX_HANDS_COLOR 10
    #define MAX_HANDS_NUMBER  10
    #define HAND_LIKELY_AREA 2000
    #define DELTA_POINT_DISTENCE 25     //手部中心点1和中心点2距离的阈值
    #define SEGMENT_POINT1_DISTANCE 27  //凸点与手部中心点1远近距离的阈值
    #define SEGMENT_POINT2_DISTANCE 30  //凸点与手部中心点2远近距离的阈值
    
    using namespace cv;
    using namespace xn;
    using namespace std;


    int main (int argc, char **argv)
    {
        unsigned int convex_number_above_point1 = 0;
        unsigned int concave_number_above_point1 = 0;
        unsigned int convex_number_above_point2 = 0;
        unsigned int concave_number_above_point2 = 0;
        unsigned int convex_assist_above_point1 = 0;
        unsigned int convex_assist_above_point2 = 0;
        unsigned int point_y1 = 0;
        unsigned int point_y2 = 0;
        int number_result = -1;
        bool recognition_flag = false;  //开始手部数字识别的标志
    
        vector<Scalar> color_array;//采用默认的10种颜色
        {
            color_array.push_back(Scalar(255, 0, 0));
            color_array.push_back(Scalar(0, 255, 0));
            color_array.push_back(Scalar(0, 0, 255));
            color_array.push_back(Scalar(255, 0, 255));
            color_array.push_back(Scalar(255, 255, 0));
            color_array.push_back(Scalar(0, 255, 255));
            color_array.push_back(Scalar(128, 255, 0));
            color_array.push_back(Scalar(0, 128, 255));
            color_array.push_back(Scalar(255, 0, 128));
            color_array.push_back(Scalar(255, 128, 255));
        }
        vector<unsigned int> hand_depth(MAX_HANDS_NUMBER, 0);
        vector<Rect> hands_roi(MAX_HANDS_NUMBER, Rect(XRES/2, YRES/2, ROI_HAND_WIDTH, ROI_HAND_HEIGHT));
    
        namedWindow("color image", CV_WINDOW_AUTOSIZE);
        namedWindow("depth image", CV_WINDOW_AUTOSIZE);
        namedWindow("hand_segment", CV_WINDOW_AUTOSIZE);    //显示分割出来的手的区域
        namedWindow("handrecognition", CV_WINDOW_AUTOSIZE); //显示0~5数字识别的图像
    
        COpenNI openni;
        if(!openni.Initial())
            return 1;
    
        if(!openni.Start())
            return 1;
        while(1) {
            if(!openni.UpdateData()) {
                return 1;
            }
            /*获取并显示色彩图像*/
            Mat color_image_src(openni.image_metadata_.YRes(), openni.image_metadata_.XRes(),
                                CV_8UC3, (char *)openni.image_metadata_.Data());
            Mat color_image;
            cvtColor(color_image_src, color_image, CV_RGB2BGR);
            Mat hand_segment_mask(color_image.size(), CV_8UC1, Scalar::all(0));
    
            for(auto itUser = openni.hand_points_.cbegin(); itUser != openni.hand_points_.cend(); ++itUser) {
    
                point_y1 = itUser->second.Y;
                point_y2 = itUser->second.Y + DELTA_POINT_DISTENCE;
                circle(color_image, Point(itUser->second.X, itUser->second.Y),
                       5, color_array.at(itUser->first % color_array.size()), 3, 8);
    
                /*设置不同手部的深度*/
                hand_depth.at(itUser->first % MAX_HANDS_COLOR) = (unsigned int)(itUser->second.Z* DEPTH_SCALE_FACTOR);//itUser->first会导致程序出现bug
    
                /*设置不同手部的不同感兴趣区域*/
                hands_roi.at(itUser->first % MAX_HANDS_NUMBER) = Rect(itUser->second.X - ROI_HAND_WIDTH/2, itUser->second.Y - ROI_HAND_HEIGHT/2,
                                                   ROI_HAND_WIDTH, ROI_HAND_HEIGHT);
                hands_roi.at(itUser->first % MAX_HANDS_NUMBER).x =  itUser->second.X - ROI_HAND_WIDTH/2;
                hands_roi.at(itUser->first % MAX_HANDS_NUMBER).y =  itUser->second.Y - ROI_HAND_HEIGHT/2;
                hands_roi.at(itUser->first % MAX_HANDS_NUMBER).width = ROI_HAND_WIDTH;
                hands_roi.at(itUser->first % MAX_HANDS_NUMBER).height = ROI_HAND_HEIGHT;
                if(hands_roi.at(itUser->first % MAX_HANDS_NUMBER).x <= 0)
                    hands_roi.at(itUser->first % MAX_HANDS_NUMBER).x  = 0;
                if(hands_roi.at(itUser->first % MAX_HANDS_NUMBER).x > XRES)
                    hands_roi.at(itUser->first % MAX_HANDS_NUMBER).x =  XRES;
                if(hands_roi.at(itUser->first % MAX_HANDS_NUMBER).y <= 0)
                    hands_roi.at(itUser->first % MAX_HANDS_NUMBER).y = 0;
                if(hands_roi.at(itUser->first % MAX_HANDS_NUMBER).y > YRES)
                    hands_roi.at(itUser->first % MAX_HANDS_NUMBER).y =  YRES;
            }
            imshow("color image", color_image);
    
            /*获取并显示深度图像*/
            Mat depth_image_src(openni.depth_metadata_.YRes(), openni.depth_metadata_.XRes(),
                                CV_16UC1, (char *)openni.depth_metadata_.Data());//因为kinect获取到的深度图像实际上是无符号的16位数据
            Mat depth_image;
            depth_image_src.convertTo(depth_image, CV_8U, DEPTH_SCALE_FACTOR);
            imshow("depth image", depth_image);
    
            //取出手的mask部分
            //不管原图像时多少通道的，mask矩阵声明为单通道就ok
            for(auto itUser = openni.hand_points_.cbegin(); itUser != openni.hand_points_.cend(); ++itUser) {
                for(int i = hands_roi.at(itUser->first % MAX_HANDS_NUMBER).x; i < std::min(hands_roi.at(itUser->first % MAX_HANDS_NUMBER).x+hands_roi.at(itUser->first % MAX_HANDS_NUMBER).width, XRES); i++)
                    for(int j = hands_roi.at(itUser->first % MAX_HANDS_NUMBER).y; j < std::min(hands_roi.at(itUser->first % MAX_HANDS_NUMBER).y+hands_roi.at(itUser->first % MAX_HANDS_NUMBER).height, YRES); j++) {
                        hand_segment_mask.at<unsigned char>(j, i) = ((hand_depth.at(itUser->first % MAX_HANDS_NUMBER)-DEPTH_SEGMENT_THRESH) < depth_image.at<unsigned char>(j, i))
                                                                    & ((hand_depth.at(itUser->first % MAX_HANDS_NUMBER)+DEPTH_SEGMENT_THRESH) > depth_image.at<unsigned char>(j,i));
                    }
             }
            medianBlur(hand_segment_mask, hand_segment_mask, MEDIAN_BLUR_K);
            Mat hand_segment(color_image.size(), CV_8UC3);
            color_image.copyTo(hand_segment, hand_segment_mask);
    
            /*对mask图像进行轮廓提取,并在手势识别图像中画出来*/
            std::vector< std::vector<Point> > contours;
            findContours(hand_segment_mask, contours, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);//找出mask图像的轮廓
            Mat hand_recognition_image = Mat::zeros(color_image.rows, color_image.cols, CV_8UC3);
    
            for(int i = 0; i < contours.size(); i++) {  //只有在检测到轮廓时才会去求它的多边形，凸包集，凹陷集
                recognition_flag = true;
                /*找出轮廓图像多边形拟合曲线*/
                Mat contour_mat = Mat(contours[i]);
                if(contourArea(contour_mat) > HAND_LIKELY_AREA) {   //比较有可能像手的区域
                    std::vector<Point> approx_poly_curve;
                    approxPolyDP(contour_mat, approx_poly_curve, 10, true);//找出轮廓的多边形拟合曲线
                    std::vector< std::vector<Point> > approx_poly_curve_debug;
                    approx_poly_curve_debug.push_back(approx_poly_curve);
    
                     drawContours(hand_recognition_image, contours, i, Scalar(255, 0, 0), 1, 8); //画出轮廓
        //            drawContours(hand_recognition_image, approx_poly_curve_debug, 0, Scalar(256, 128, 128), 1, 8); //画出多边形拟合曲线
    
                    /*对求出的多边形拟合曲线求出其凸包集*/
                    vector<int> hull;
                    convexHull(Mat(approx_poly_curve), hull, true);
                    for(int i = 0; i < hull.size(); i++) {
                        circle(hand_recognition_image, approx_poly_curve[hull[i]], 2, Scalar(0, 255, 0), 2, 8);
    
                        /*统计在中心点1以上凸点的个数*/
                        if(approx_poly_curve[hull[i]].y <= point_y1) {
                            /*统计凸点与中心点1的y轴距离*/
                            long dis_point1 = abs(long(point_y1 - approx_poly_curve[hull[i]].y));
                            int dis1 = point_y1 - approx_poly_curve[hull[i]].y;
                            if(dis_point1 > SEGMENT_POINT1_DISTANCE && dis1 >= 0)  {
                                convex_assist_above_point1++;
                            }
                            convex_number_above_point1++;
                        }
    
                        /*统计在中心点2以上凸点的个数*/
                        if(approx_poly_curve[hull[i]].y <= point_y2)    {
                            /*统计凸点与中心点1的y轴距离*/
                            long dis_point2 = abs(long(point_y2 - approx_poly_curve[hull[i]].y));
                            int dis2 = point_y2 - approx_poly_curve[hull[i]].y;
                            if(dis_point2 > SEGMENT_POINT2_DISTANCE && dis2 >= 0)  {
                                convex_assist_above_point2++;
                            }
                            convex_number_above_point2++;
                        }
                    }
    
        //            /*对求出的多边形拟合曲线求出凹陷集*/
                    std::vector<Vec4i> convexity_defects;
                    if(Mat(approx_poly_curve).checkVector(2, CV_32S) > 3)
                        convexityDefects(approx_poly_curve, Mat(hull), convexity_defects);
                    for(int i = 0; i < convexity_defects.size(); i++) {
                        circle(hand_recognition_image, approx_poly_curve[convexity_defects[i][2]] , 2, Scalar(0, 0, 255), 2, 8);
    
                        /*统计在中心点1以上凹陷点的个数*/
                        if(approx_poly_curve[convexity_defects[i][2]].y <= point_y1)
                            concave_number_above_point1++;
    
                        /*统计在中心点2以上凹陷点的个数*/
                        if(approx_poly_curve[convexity_defects[i][2]].y <= point_y2)
                            concave_number_above_point2++;
                    }
                }
            }
    
            /**画出手势的中心点**/
            for(auto itUser = openni.hand_points_.cbegin(); itUser != openni.hand_points_.cend(); ++itUser) {
                circle(hand_recognition_image, Point(itUser->second.X, itUser->second.Y), 3, Scalar(0, 255, 255), 3, 8);
                circle(hand_recognition_image, Point(itUser->second.X, itUser->second.Y + 25), 3, Scalar(255, 0, 255), 3, 8);
            }
    
            /*手势数字0~5的识别*/
            //"0"的识别
            if((convex_assist_above_point1 ==0 && convex_number_above_point2 >= 2 && convex_number_above_point2 <= 3 &&
                    concave_number_above_point2 <= 1 && concave_number_above_point1 <= 1) || (concave_number_above_point1 ==0
                    || concave_number_above_point2 == 0) && recognition_flag == true)
                number_result = 0;
            //"1"的识别
            if(convex_assist_above_point1 ==1 && convex_number_above_point1 >=1  && convex_number_above_point1 <=2 &&
                    convex_number_above_point2 >=2 && convex_assist_above_point2 == 1)
                number_result = 1;
            //"2"的识别
            if(convex_number_above_point1 == 2 && concave_number_above_point1 == 1 && convex_assist_above_point2 == 2
                    /*convex_assist_above_point1 <=1*/ && concave_number_above_point2 == 1)
                number_result = 2;
            //"3"的识别
            if(convex_number_above_point1 == 3 && concave_number_above_point1 <= 3 &&
                    concave_number_above_point1 >=1 && convex_number_above_point2 >= 3 && convex_number_above_point2 <= 4 &&
                    convex_assist_above_point2 == 3)
                number_result = 3;
            //"4"的识别
            if(convex_number_above_point1 == 4 && concave_number_above_point1 <=3 && concave_number_above_point1 >=2 &&
                    convex_number_above_point2 == 4)
                number_result = 4;
            //"5"的识别
            if(convex_number_above_point1 >=4 && convex_number_above_point2 == 5 && concave_number_above_point2 >= 3 &&
                    convex_number_above_point2 >= 4)
                number_result = 5;
            if(number_result !=0 && number_result != 1  && number_result != 2 && number_result != 3 && number_result != 4 && number_result != 5)
                number_result == -1;
    
            /*在手势识别图上显示匹配的数字*/
            std::stringstream number_str;
            number_str << number_result;
            putText(hand_recognition_image, "Match: ", Point(0, 60), 4, 1, Scalar(0, 255, 0), 2, 0 );
            if(number_result == -1)
                putText(hand_recognition_image, " ", Point(120, 60), 4, 2, Scalar(255, 0 ,0), 2, 0);
            else
                putText(hand_recognition_image, number_str.str(), Point(150, 60), 4, 2, Scalar(255, 0 ,0), 2, 0);
    
            imshow("handrecognition", hand_recognition_image);
            imshow("hand_segment", hand_segment);
    
            /*一个循环中对有些变量进行初始化操作*/
            convex_number_above_point1 = 0;
            convex_number_above_point2 = 0;
            concave_number_above_point1 = 0;
            concave_number_above_point2 = 0;
            convex_assist_above_point1 = 0;
            convex_assist_above_point2 = 0;
            number_result = -1;
            recognition_flag = false;
            number_str.clear();
    
            waitKey(20);
        }
    
    }



    #include "copenni.h"
    #include 
    #include 
    #include 
    
    using namespace xn;
    using namespace std;
    
    COpenNI::COpenNI()
    {
    }
    
    COpenNI::~COpenNI()
    {
    }
    
    bool COpenNI::Initial()
    {
        status_ = context_.Init();
        if(CheckError("Context initial failed!")) {
            return false;
        }
    
        context_.SetGlobalMirror(true);//设置镜像
        xmode_.nXRes = 640;
        xmode_.nYRes = 480;
        xmode_.nFPS = 30;
    
        //产生颜色node
        status_ = image_generator_.Create(context_);
        if(CheckError("Create image generator  error!")) {
            return false;
        }
    
        //设置颜色图片输出模式
        status_ = image_generator_.SetMapOutputMode(xmode_);
        if(CheckError("SetMapOutputMdoe error!")) {
            return false;
        }
    
        //产生深度node
        status_ = depth_generator_.Create(context_);
        if(CheckError("Create depth generator  error!")) {
            return false;
        }
    
        //设置深度图片输出模式
        status_ = depth_generator_.SetMapOutputMode(xmode_);
        if(CheckError("SetMapOutputMdoe error!")) {
            return false;
        }
    
        //产生手势node
        status_ = gesture_generator_.Create(context_);
        if(CheckError("Create gesture generator error!")) {
            return false;
        }
    
        /*添加手势识别的种类*/
        gesture_generator_.AddGesture("Wave", NULL);
        gesture_generator_.AddGesture("click", NULL);
        gesture_generator_.AddGesture("RaiseHand", NULL);
        gesture_generator_.AddGesture("MovingHand", NULL);
    
        //产生手部的node
        status_ = hand_generator_.Create(context_);
        if(CheckError("Create hand generaotr error!")) {
            return false;
        }
    
        //产生人体node
        status_ = user_generator_.Create(context_);
        if(CheckError("Create gesturen generator error!")) {
            return false;
        }
    
        //视角校正
        status_ = depth_generator_.GetAlternativeViewPointCap().SetViewPoint(image_generator_);
        if(CheckError("Can't set the alternative view point on depth generator!")) {
            return false;
        }
    
        //设置与手势有关的回调函数
        XnCallbackHandle gesture_cb;
        gesture_generator_.RegisterGestureCallbacks(CBGestureRecognized, CBGestureProgress, this, gesture_cb);
    
        //设置于手部有关的回调函数
        XnCallbackHandle hands_cb;
        hand_generator_.RegisterHandCallbacks(HandCreate, HandUpdate, HandDestroy, this, hands_cb);
    
        //设置有人进入视野的回调函数
        XnCallbackHandle new_user_handle;
        user_generator_.RegisterUserCallbacks(CBNewUser, NULL, NULL, new_user_handle);
        user_generator_.GetSkeletonCap().SetSkeletonProfile(XN_SKEL_PROFILE_ALL);//设定使用所有关节（共15个）
    
        //设置骨骼校正完成的回调函数
        XnCallbackHandle calibration_complete;
        user_generator_.GetSkeletonCap().RegisterToCalibrationComplete(CBCalibrationComplete, this, calibration_complete);
        return true;
    }
    
    bool COpenNI::Start()
    {
        status_ = context_.StartGeneratingAll();
        if(CheckError("Start generating error!")) {
            return false;
        }
        return true;
    }
    
    bool COpenNI::UpdateData()
    {
        status_ = context_.WaitNoneUpdateAll();
        if(CheckError("Update date error!")) {
            return false;
        }
        //获取数据
        image_generator_.GetMetaData(image_metadata_);
        depth_generator_.GetMetaData(depth_metadata_);
    
        return true;
    }
    
    ImageGenerator &COpenNI::getImageGenerator()
    {
        return image_generator_;
    }
    
    DepthGenerator &COpenNI::getDepthGenerator()
    {
        return depth_generator_;
    }
    
    UserGenerator &COpenNI::getUserGenerator()
    {
        return user_generator_;
    }
    
    GestureGenerator &COpenNI::getGestureGenerator()
    {
        return gesture_generator_;
    }
    
    HandsGenerator &COpenNI::getHandGenerator()
    {
        return hand_generator_;
    }
    
    bool COpenNI::CheckError(const char *error)
    {
        if(status_ != XN_STATUS_OK) {
            cerr << error << ": " << xnGetStatusString( status_ ) << endl;
            return true;
        }
        return false;
    }
    
    void COpenNI::CBNewUser(UserGenerator &generator, XnUserID user, void *p_cookie)
    {
        //得到skeleton的capability,并调用RequestCalibration函数设置对新检测到的人进行骨骼校正
        generator.GetSkeletonCap().RequestCalibration(user, true);
    }
    
    void COpenNI::CBCalibrationComplete(SkeletonCapability &skeleton, XnUserID user, XnCalibrationStatus calibration_error, void *p_cookie)
    {
        if(calibration_error == XN_CALIBRATION_STATUS_OK) {
            skeleton.StartTracking(user);//骨骼校正完成后就开始进行人体跟踪了
        }
        else {
            UserGenerator *p_user = (UserGenerator*)p_cookie;
            skeleton.RequestCalibration(user, true);//骨骼校正失败时重新设置对人体骨骼继续进行校正
        }
    }
    
    void COpenNI::CBGestureRecognized(GestureGenerator &generator, const XnChar *strGesture, const XnPoint3D *pIDPosition, const XnPoint3D *pEndPosition, void *pCookie)
    {
        COpenNI *openni = (COpenNI*)pCookie;
        openni->hand_generator_.StartTracking(*pEndPosition);
    }
    
    void COpenNI::CBGestureProgress(GestureGenerator &generator, const XnChar *strGesture, const XnPoint3D *pPosition, XnFloat fProgress, void *pCookie)
    {
    }
    
    void COpenNI::HandCreate(HandsGenerator &rHands, XnUserID xUID, const XnPoint3D *pPosition, XnFloat fTime, void *pCookie)
    {
        COpenNI *openni = (COpenNI*)pCookie;
        XnPoint3D project_pos;
        openni->depth_generator_.ConvertRealWorldToProjective(1, pPosition, &project_pos);
        pair<XnUserID, XnPoint3D> hand_point_pair(xUID, XnPoint3D());//在进行pair类型的定义时，可以将第2个设置为空
        hand_point_pair.second = project_pos;
        openni->hand_points_.insert(hand_point_pair);//将检测到的手部存入map类型的hand_points_中。
    
        pair<XnUserID, vector<XnPoint3D>> hand_track_point(xUID, vector<XnPoint3D>());
        hand_track_point.second.push_back(project_pos);
        openni->hands_track_points_.insert(hand_track_point);
    }
    
    void COpenNI::HandUpdate(HandsGenerator &rHands, XnUserID xUID, const XnPoint3D *pPosition, XnFloat fTime, void *pCookie)
    {
        COpenNI *openni = (COpenNI*)pCookie;
        XnPoint3D project_pos;
        openni->depth_generator_.ConvertRealWorldToProjective(1, pPosition, &project_pos);
        openni->hand_points_.find(xUID)->second = project_pos;
        openni->hands_track_points_.find(xUID)->second.push_back(project_pos);
    }
    
    void COpenNI::HandDestroy(HandsGenerator &rHands, XnUserID xUID, XnFloat fTime, void *pCookie)
    {
        COpenNI *openni = (COpenNI*)pCookie;
        openni->hand_points_.erase(openni->hand_points_.find(xUID));
        openni->hands_track_points_.erase(openni->hands_track_points_.find(xUID ));
    }

3 深度学习方法做手势识别

3.1 经典的卷积神经网络

卷积神经网络的优势就在于它能够从常见的视觉任务中自动学习目 标数据的特征， 然后将这些特征用于某种特定任务的模型。 随着时代的发展，
深度学习也形成了一些经典的卷积神经网络。

3.2 YOLO系列

YOLO 系列的网络模型最早源于 2016 年， 之后几年经过不断改进相继推出YOLOv2、 YOLOv3
等网络，直到今日yoloV5也诞生了，不得不感慨一句，darknet是真的肝。

最具代表性的yolov3的结构

在这里插入图片描述

3.3 SSD

SSD 作为典型的一阶段网络模型， 具有更高的操作性， 端到端的学习模式同样受到众多研究者的喜爱

在这里插入图片描述

3.4 实现步骤

3.4.1 数据集

手势识别的数据集来自于丹成学长实验室，由于中国手势表示3的手势根据地区有略微差异，按照这个数据集的手势训练与测试即可。

  • 图像大小：100*100 像素
  • 颜色空间：RGB 种类：
  • 图片种类：6 种(0,1,2,3,4,5)
  • 每种图片数量：200 张

一共6种手势，每种手势200张图片，共1200张图片（100x100RGB）

在这里插入图片描述

3.4.2 图像预处理

在这里插入图片描述

实际图片处理展示：resize前先高斯模糊，提取边缘后可以根据实际需要增加一次中值滤波去噪：

在这里插入图片描述

3.4.3 构建卷积神经网络结构

使用tensorflow的框架，构建一个简单的网络结构

在这里插入图片描述

在这里插入图片描述

Dropout： 增加鲁棒性帮助正则化和避免过拟合

一个相关的早期使用这种技术的论文（（ImageNet Classification with Deep Convolutional Neural
Networks, by Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton
(2012).））中启发性的dropout解释是:

因为一个神经元不能依赖其他特定的神经元。因此，不得不去学习随机子集神经元间的鲁棒性的有用连接。换句话说。想象我们的神经元作为要给预测的模型，dropout是一种方式可以确保我们的模型在丢失一个个体线索的情况下保持健壮的模型。在这种情况下，可以说他的作用和L1和L2范式正则化是相同的。都是来减少权重连接，然后增加网络模型在缺失个体连接信息情况下的鲁棒性。在提高神经网络表现方面效果较好。

3.4.4 实验训练过程及结果

经过约4800轮的训练后，loss基本收敛，在0.6左右，在120份的测试样本上的模型准确率能够达到约96%

在这里插入图片描述

在这里插入图片描述

3.5 关键代码

​


    import tensorflow as tf
    IMAGE_SIZE = 100
    NUM_CHANNELS = 1
    CONV1_SIZE = 4
    CONV1_KERNEL_NUM = 8
    CONV2_SIZE = 2
    CONV2_KERNEL_NUM = 16
    FC_SIZE = 512
    OUTPUT_NODE = 6
    
    def get_weight(shape, regularizer):
    	w = tf.Variable(tf.truncated_normal(shape,stddev=0.1))
    	if regularizer != None: tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w)) 
    	return w
    
    def get_bias(shape): 
    	b = tf.Variable(tf.zeros(shape))  
    	return b
    
    def conv2d(x,w):  
    	return tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME')
    
    def max_pool_8x8(x):  
    	return tf.nn.max_pool(x, ksize=[1, 8, 8, 1], strides=[1, 4, 4, 1], padding='SAME')
    
    def max_pool_4x4(x):  
    	return tf.nn.max_pool(x, ksize=[1, 4, 4, 1], strides=[1, 2, 2, 1], padding='SAME')
    
    def forward(x, train, regularizer):
        
        conv1_w = get_weight([CONV1_SIZE, CONV1_SIZE, NUM_CHANNELS, CONV1_KERNEL_NUM], regularizer) 
        conv1_b = get_bias([CONV1_KERNEL_NUM]) 
        conv1 = conv2d(x, conv1_w) 
        relu1 = tf.nn.relu(tf.nn.bias_add(conv1, conv1_b)) 
        pool1 = max_pool_8x8(relu1) 
    
        conv2_w = get_weight([CONV2_SIZE, CONV2_SIZE, CONV1_KERNEL_NUM, CONV2_KERNEL_NUM],regularizer) 
        conv2_b = get_bias([CONV2_KERNEL_NUM])
        conv2 = conv2d(pool1, conv2_w) 
        relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_b))
        pool2 = max_pool_4x4(relu2)
    
        pool_shape = pool2.get_shape().as_list() 
        nodes = pool_shape[1] * pool_shape[2] * pool_shape[3] 
        reshaped = tf.reshape(pool2, [pool_shape[0], nodes]) 
    
        fc1_w = get_weight([nodes, FC_SIZE], regularizer) 
        fc1_b = get_bias([FC_SIZE]) 
        fc1 = tf.nn.relu(tf.matmul(reshaped, fc1_w) + fc1_b) 
        if train: fc1 = tf.nn.dropout(fc1, 0.5)
    
        fc2_w = get_weight([FC_SIZE, OUTPUT_NODE], regularizer)
        fc2_b = get_bias([OUTPUT_NODE])
        y = tf.matmul(fc1, fc2_w) + fc2_b
        return y 


    import tensorflow as tf
    import numpy as np
    import gesture_forward
    import gesture_backward
    from image_processing import func5,func6
    import cv2
    
    def restore_model(testPicArr):
        with tf.Graph().as_default() as tg:
            
            x = tf.placeholder(tf.float32,[
                1,
                gesture_forward.IMAGE_SIZE,
                gesture_forward.IMAGE_SIZE,
                gesture_forward.NUM_CHANNELS])    
            #y_ = tf.placeholder(tf.float32, [None, mnist_lenet5_forward.OUTPUT_NODE])
            y = gesture_forward.forward(x,False,None)
            
            preValue = tf.argmax(y, 1)
    
            variable_averages = tf.train.ExponentialMovingAverage(gesture_backward.MOVING_AVERAGE_DECAY)
            variables_to_restore = variable_averages.variables_to_restore()
            saver = tf.train.Saver(variables_to_restore)
            
            with tf.Session() as sess:
                ckpt = tf.train.get_checkpoint_state(gesture_backward.MODEL_SAVE_PATH)
                if ckpt and ckpt.model_checkpoint_path:
                    saver.restore(sess, ckpt.model_checkpoint_path)
                    #global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1] 
                    preValue = sess.run(preValue, feed_dict={x:testPicArr})
                    return preValue
                else:
                    print("No checkpoint file found")
                    return -1


    def application01():
        testNum = input("input the number of test pictures:")
        testNum = int(testNum)
        for i in range(testNum):
            testPic = input("the path of test picture:")
            img = func5(testPic)
            cv2.imwrite(str(i)+'ttt.jpg',img)   
    #        cv2.waitKey(0)
    #        cv2.destroyAllWindows()
            img = img.reshape([1,100,100,1])
            img = img.astype(np.float32)
            img = np.multiply(img, 1.0/255.0)
    #        print(img.shape)
    #        print(type(img))        
            preValue = restore_model(img)
            print ("The prediction number is:", preValue)
    
    def application02():
        
        #vc = cv2.VideoCapture('testVideo.mp4')
        vc = cv2.VideoCapture(0)
        # 设置每秒传输帧数
        fps = vc.get(cv2.CAP_PROP_FPS)
        # 获取视频的大小
        size = (int(vc.get(cv2.CAP_PROP_FRAME_WIDTH)),int(vc.get(cv2.CAP_PROP_FRAME_HEIGHT)))
        # 生成一个空的视频文件
        # 视频编码类型
        # cv2.VideoWriter_fourcc('X','V','I','D') MPEG-4 编码类型
        # cv2.VideoWriter_fourcc('I','4','2','0') YUY编码类型
        # cv2.VideoWriter_fourcc('P','I','M','I') MPEG-1 编码类型
        # cv2.VideoWriter_fourcc('T','H','E','O') Ogg Vorbis类型，文件名为.ogv
        # cv2.VideoWriter_fourcc('F','L','V','1') Flask视频，文件名为.flv
        #vw = cv2.VideoWriter('ges_pro.avi',cv2.VideoWriter_fourcc('X','V','I','D'), fps, size)
        # 读取视频第一帧的内容
        success, frame = vc.read()
    #    rows = frame.shape[0]    
    #    cols = frame.shape[1]
    #    t1 = int((cols-rows)/2)
    #    t2 = int(cols-t1)
    #    M = cv2.getRotationMatrix2D((cols/2,rows/2),90,1)
    #    frame = cv2.warpAffine(frame,M,(cols,rows))
    #    frame = frame[0:rows, t1:t2]
    #    cv2.imshow('sd',frame)
    #    cv2.waitKey(0)
    #    cv2.destroyAllWindows()
        while success:
            
            #90度旋转        
    #        img = cv2.warpAffine(frame,M,(cols,rows))
    #        img = img[0:rows, t1:t2]
            img = func6(frame)
            img = img.reshape([1,100,100,1])
            img = img.astype(np.float32)
            img = np.multiply(img, 1.0/255.0)
            preValue = restore_model(img)
            # 写入视频
            cv2.putText(frame,"Gesture:"+str(preValue),(50,50),cv2.FONT_HERSHEY_PLAIN,2.0,(0,0,255),1)
            #vw.write(frame)
            cv2.imshow('gesture',frame)
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
            # 读取视频下一帧的内容
            success, frame = vc.read()
        
        vc.release()
        cv2.destroyAllWindows()    
        print('viedo app over!')


    def main():
        #application01()
        application02()
        
    if __name__ == '__main__':
    	main()

4 最后

更多资料, 项目分享：

https://gitee.com/dancheng-senior/postgraduate

你可能感兴趣的:(python)

  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • python os.environ 江湖偌大 python深度学习
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • python八股文面试题分享及解析(1) Shawn________ python
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • Python 实现图片裁剪（附代码） | Python工具 剑客阿良_ALiang
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • Python中深拷贝与浅拷贝的区别 yuxiaoyu.
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • Python编译器 鹿鹿~ Python编译器Pythonpython开发语言后端
    嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt
  • 一文掌握python面向对象魔术方法（二） 程序员neil pythonpython开发语言
    接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
  • 一文掌握python常用的list（列表）操作 程序员neil pythonpython开发语言
    目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
  • Python实现简单的机器学习算法 master_chenchengg pythonpython办公效率python开发IT
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
  • python中的深拷贝与浅拷贝 anshejd70787 python
    深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis
  • 用Python实现简单的猜数字游戏 程序媛了了 python游戏java
    猜数字游戏代码：importrandomdefpythonit():a=random.randint(1,100)n=int(input("输入你猜想的数字："))whilen!=a:ifn>a:print("很遗憾，猜大了")n=int(input("请再次输入你猜想的数字："))elifna::如果玩家猜的数字n大于随机数字a，则输出"很遗憾，猜大了"，并提示玩家再次输入。elifn
  • 用Python实现读取统计单词个数 程序媛了了 python游戏java
    完整实例代码：fromcollectionsimportCounterdefpythonit():danci={}withopen("pythonit.txt","r",encoding="utf-8")asf:foriinf:words=i.strip().split()forwordinwords:ifwordnotindanci:danci[word]=1else:danci[word]+=
  • Linux的Initrd机制 被触发 linux
    Linux 的 initrd 技术是一个非常普遍使用的机制，linux2.6 内核的 initrd 的文件格式由原来的文件系统镜像文件转变成了 cpio 格式，变化不仅反映在文件格式上， linux 内核对这两种格式的 initrd 的处理有着截然的不同。本文首先介绍了什么是 initrd 技术，然后分别介绍了 Linux2.4 内核和 2.6 内核的 initrd 的处理流程。最后通过对 Lin
  • maven本地仓库路径修改 bitcarter maven
    默认maven本地仓库路径：C:\Users\Administrator\.m2 修改maven本地仓库路径方法：     1.打开E:\maven\apache-maven-2.2.1\conf\settings.xml     2.找到        
  • XSD和XML中的命名空间 darrenzhu xmlxsdschemanamespace命名空间
    http://www.360doc.com/content/12/0418/10/9437165_204585479.shtml http://blog.csdn.net/wanghuan203/article/details/9203621 http://blog.csdn.net/wanghuan203/article/details/9204337 http://www.cn
  • Java 求素数运算 周凡杨 java算法素数
    网络上对求素数之解数不胜数，我在此总结归纳一下，同时对一些编码，加以改进，效率有成倍热提高。 第一种：   原理: 6N(+-)1法         任何一个自然数，总可以表示成为如下的形式之一： 6N，6N+1，6N+2，6N+3，6N+4，6N+5 (N=0，1，2，…)   
  • java 单例模式 g21121 java
    想必单例模式大家都不会陌生，有如下两种方式来实现单例模式：   class Singleton { private static Singleton instance=new Singleton(); private Singleton(){} static Singleton getInstance() { return instance; }
  • Linux下Mysql源码安装 510888780 mysql
    1.假设已经有mysql-5.6.23-linux-glibc2.5-x86_64.tar.gz (1)创建mysql的安装目录及数据库存放目录       解压缩下载的源码包，目录结构，特殊指定的目录除外：           
  • 32位和64位操作系统 墙头上一根草 32位和64位操作系统
    32位和64位操作系统是指：CPU一次处理数据的能力是32位还是64位。现在市场上的CPU一般都是64位的，但是这些CPU并不是真正意义上的64 位CPU，里面依然保留了大部分32位的技术，只是进行了部分64位的改进。32位和64位的区别还涉及了内存的寻址方面，32位系统的最大寻址空间是2 的32次方= 4294967296（bit）= 4（GB）左右，而64位系统的最大寻址空间的寻址空间则达到了
  • 我的spring学习笔记10-轻量级_Spring框架 aijuans Spring 3
    一、问题提问：     → 请简单介绍一下什么是轻量级？     轻量级（Leightweight）是相对于一些重量级的容器来说的，比如Spring的核心是一个轻量级的容器，Spring的核心包在文件容量上只有不到1M大小，使用Spring核心包所需要的资源也是很少的，您甚至可以在小型设备中使用Spring。  
  • mongodb 环境搭建及简单CURD antlove WebInstallcurdNoSQLmongo
    一 搭建mongodb环境 1. 在mongo官网下载mongodb 2. 在本地创建目录 "D:\Program Files\mongodb-win32-i386-2.6.4\data\db" 3. 运行mongodb服务 [mongod.exe --dbpath "D:\Program Files\mongodb-win32-i386-2.6.4\data\
  • 数据字典和动态视图 百合不是茶 oracle数据字典动态视图系统和对象权限
    数据字典（data dictionary）是 Oracle 数据库的一个重要组成部分，这是一组用于记录数据库信息的只读（read-only）表。随着数据库的启动而启动,数据库关闭时数据字典也关闭   数据字典中包含   数据库中所有方案对象（schema object）的定义(包括表，视图，索引，簇，同义词，序列，过程，函数，包，触发器等等) 数据库为一
  • 多线程编程一般规则 bijian1013 javathread多线程java多线程
           如果两个工两个以上的线程都修改一个对象，那么把执行修改的方法定义为被同步的，如果对象更新影响到只读方法，那么只读方法也要定义成同步的。        不要滥用同步。如果在一个对象内的不同的方法访问的不是同一个数据，就不要将方法设置为synchronized的。
  • 将文件或目录拷贝到另一个Linux系统的命令scp bijian1013 linuxunixscp
    一.功能说明        scp就是security copy，用于将文件或者目录从一个Linux系统拷贝到另一个Linux系统下。scp传输数据用的是SSH协议，保证了数据传输的安全，其格式如下：        scp 远程用户名@IP地址：文件的绝对路径
  • 【持久化框架MyBatis3五】MyBatis3一对多关联查询 bit1129 Mybatis3
    以教员和课程为例介绍一对多关联关系，在这里认为一个教员可以叫多门课程，而一门课程只有1个教员教，这种关系在实际中不太常见，通过教员和课程是多对多的关系。   示例数据：   地址表：   CREATE TABLE ADDRESSES ( ADDR_ID INT(11) NOT NULL AUTO_INCREMENT, STREET VAR
  • cookie状态判断引发的查找问题 bitcarter formcgi
    先说一下我们的业务背景： 1.前台将图片和文本通过form表单提交到后台，图片我们都做了base64的编码，并且前台图片进行了压缩 2.form中action是一个cgi服务 3.后台cgi服务同时供PC，H5，APP 4.后台cgi中调用公共的cookie状态判断方法（公共的，大家都用，几年了没有问题） 问题：（折腾两天。。。。） 1.PC端cgi服务正常调用，cookie判断没
  • 通过Nginx,Tomcat访问日志(access log)记录请求耗时 ronin47
    一、Nginx通过$upstream_response_time $request_time统计请求和后台服务响应时间 nginx.conf使用配置方式： log_format main '$remote_addr - $remote_user [$time_local] "$request" ''$status $body_bytes_sent "$http_r
  • java-67- n个骰子的点数。 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。 bylijinnan java
    public class ProbabilityOfDice { /** * Q67 n个骰子的点数 * 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。 * 在以下求解过程中，我们把骰子看作是有序的。 * 例如当n=2时，我们认为（1，2）和（2，1）是两种不同的情况 */ private stati
  • 看别人的博客，觉得心情很好 Cb123456 博客心情
       以为写博客，就是总结，就和日记一样吧，同时也在督促自己。今天看了好长时间博客:    职业规划:    http://www.iteye.com/blogs/subjects/zhiyeguihua      android学习:    1.http://byandby.i
  • [JWFD开源工作流]尝试用原生代码引擎实现循环反馈拓扑分析 comsci 工作流
        我们已经不满足于仅仅跳跃一次，通过对引擎的升级，今天我测试了一下循环反馈模式，大概跑了200圈，引擎报一个溢出错误      在一个流程图的结束节点中嵌入一段方程，每次引擎运行到这个节点的时候，通过实时编译器GM模块，计算这个方程，计算结果与预设值进行比较，符合条件则跳跃到开始节点，继续新一轮拓扑分析，直到遇到
  • JS常用的事件及方法 cwqcwqmax9 js
    事件 描述 onactivate 当对象设置为活动元素时触发。 onafterupdate 当成功更新数据源对象中的关联对象后在数据绑定对象上触发。 onbeforeactivate 对象要被设置为当前元素前立即触发。 onbeforecut 当选中区从文档中删除之前在源对象触发。 onbeforedeactivate 在 activeElement 从当前对象变为父文档其它对象之前立即
  • 正则表达式验证日期格式 dashuaifu 正则表达式IT其它java其它
    正则表达式验证日期格式 function isDate(d){ var v = d.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/i); if(!v) { this.focus(); return false; } } <input value="2000-8-8" onblu
  • Yii CModel.rules() 方法 、validate预定义完整列表、以及说说验证 dcj3sjt126com yii
    public array rules () {return} array 要调用 validate() 时应用的有效性规则。 返回属性的有效性规则。声明验证规则，应重写此方法。 每个规则是数组具有以下结构：array('attribute list', 'validator name', 'on'=>'scenario name', ...validation
  • UITextAttributeTextColor = deprecated in iOS 7.0 dcj3sjt126com ios
    In this lesson we used the key "UITextAttributeTextColor" to change the color of the UINavigationBar appearance to white. This prompts a warning "first deprecated in iOS 7.0." Ins
  • 判断一个数是质数的几种方法 EmmaZhao Mathpython
    质数也叫素数，是只能被1和它本身整除的正整数，最小的质数是2，目前发现的最大的质数是p=2^57885161-1【注1】。 判断一个数是质数的最简单的方法如下： def isPrime1(n): for i in range(2, n): if n % i == 0: return False return True 但是在上面的方法中有一些冗余的计算，所以
  • SpringSecurity工作原理小解读 坏我一锅粥 SpringSecurity
      SecurityContextPersistenceFilter   ConcurrentSessionFilter   WebAsyncManagerIntegrationFilter   HeaderWriterFilter   CsrfFilter   LogoutFilter   Use
  • JS实现自适应宽度的Tag切换 ini JavaScripthtmlWebcsshtml5
    效果体验：http://hovertree.com/texiao/js/3.htm   该效果使用纯JavaScript代码，实现TAB页切换效果，TAB标签根据内容自适应宽度，点击TAB标签切换内容页。 HTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"
  • Hbase Rest API : 数据查询 kane_xie RESThbase
    hbase（hadoop）是用java编写的，有些语言（例如python）能够对它提供良好的支持，但也有很多语言使用起来并不是那么方便，比如c#只能通过thrift访问。Rest就能很好的解决这个问题。Hbase的org.apache.hadoop.hbase.rest包提供了rest接口，它内嵌了jetty作为servlet容器。   启动命令：./bin/hbase rest s
  • JQuery实现鼠标拖动元素移动位置（源码+注释） 明子健 jqueryjs源码拖动鼠标
    欢迎讨论指正！   print.html代码： <!DOCTYPE html> <html> <head> <meta http-equiv=Content-Type content="text/html;charset=utf-8"> <title>发票打印</title> &l
  • Postgresql 连表更新字段语法 update qifeifei PostgreSQL
    下面这段sql本来目的是想更新条件下的数据，可是这段sql却更新了整个表的数据。sql如下： UPDATE tops_visa.visa_order SET op_audit_abort_pass_date = now() FROM tops_visa.visa_order as t1 INNER JOIN tops_visa.visa_visitor as t2 ON t1.
  • 将redis,memcache结合使用的方案? tcrct rediscache
    公司架构上使用了阿里云的服务，由于阿里的kvstore收费相当高，打算自建，自建后就需要自己维护，所以就有了一个想法，针对kvstore(redis)及ocs(memcache)的特点，想自己开发一个cache层，将需要用到list，set，map等redis方法的继续使用redis来完成，将整条记录放在memcache下，即findbyid，save等时就memcache，其它就对应使用redi
  • 开发中遇到的诡异的bug wudixiaotie bug
    今天我们服务器组遇到个问题： 我们的服务是从Kafka里面取出数据，然后把offset存储到ssdb中，每个topic和partition都对应ssdb中不同的key，服务启动之后，每次kafka数据更新我们这边收到消息，然后存储之后就发现ssdb的值偶尔是-2,这就奇怪了，最开始我们是在代码中打印存储的日志，发现没什么问题，后来去查看ssdb的日志，才发现里面每次set的时候都会对同一个key
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他