mediapipe学习-手势识别 增加简单手势识别(6)

已于 2023-03-16 21:43:08 修改
阅读量1.7k 收藏 7
点赞数 1
分类专栏： android mediapipe学习 文章标签： 学习 android android studio
于 2022-08-21 18:26:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yunteng521/article/details/126453643
版权

前言

 这章增加几个简单的手势，输出结果

1: 代码如下
在上章修改
MainActivity.java

package com.example.testhand;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.graphics.SurfaceTexture;
import android.os.Bundle;

/
import android.provider.MediaStore;
import android.util.Log;
import android.util.Size;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.TextView;

import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
//
import com.google.mediapipe.components.CameraHelper;
import com.google.mediapipe.components.CameraXPreviewHelper;
import com.google.mediapipe.components.ExternalTextureConverter;
import com.google.mediapipe.components.FrameProcessor;
import com.google.mediapipe.components.PermissionHelper;
import com.google.mediapipe.formats.proto.LandmarkProto.NormalizedLandmarkList;
import com.google.mediapipe.formats.proto.LandmarkProto.NormalizedLandmark;
import com.google.mediapipe.framework.AndroidAssetUtil;
import com.google.mediapipe.framework.AndroidPacketGetter;
import com.google.mediapipe.framework.Packet;
import com.google.mediapipe.framework.PacketGetter;
import com.google.mediapipe.glutil.EglManager;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.mediapipe.framework.AndroidPacketCreator;
///

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    // 资源文件和流输出名
    private static final String BINARY_GRAPH_NAME = "hand_tracking_mobile_gpu.binarypb";
    private static final String INPUT_VIDEO_STREAM_NAME = "input_video";
    private static final String OUTPUT_VIDEO_STREAM_NAME = "output_video";
    private static final String OUTPUT_HAND_PRESENCE_STREAM_NAME = "hand_presence";
    private static final String OUTPUT_LANDMARKS_STREAM_NAME = "hand_landmarks";
    private static final String INPUT_NUM_HANDS_SIDE_PACKET_NAME = "num_hands";
    // Max number of hands to detect/process.
    private static final int NUM_HANDS = 2;
    private static final String INPUT_MODEL_COMPLEXITY = "model_complexity";

    private SurfaceTexture previewFrameTexture;
    private SurfaceView previewDisplayView;
    private EglManager eglManager;
    private FrameProcessor processor;
    private ExternalTextureConverter converter;
    private CameraXPreviewHelper cameraHelper;
    private boolean handPresence;

    // 所使用的摄像头
    private static  boolean USE_FRONT_CAMERA = true;
    Button  button_change_camera,button_change_picture_show ;

    // 因为OpenGL表示图像时假设图像原点在左下角，而MediaPipe通常假设图像原点在左上角，所以要翻转
    private static final boolean FLIP_FRAMES_VERTICALLY = true;

    private TextView showtext;

    // 加载动态库
    static {
        System.loadLibrary("mediapipe_jni");
        System.loadLibrary("opencv_java3");
    }


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        showtext = findViewById(R.id.showtext);
        button_change_camera= findViewById(R.id.button_change_camera);
        button_change_picture_show = findViewById(R.id.button_change_picture_show);

        previewDisplayView = new SurfaceView(this);
        setupPreviewDisplayView();
        // 获取权限
        PermissionHelper.checkAndRequestCameraPermissions(this);

        // 初始化assets管理器，以便MediaPipe应用资源
        AndroidAssetUtil.initializeNativeAssetManager(this);

        eglManager = new EglManager(null);
        // 通过加载获取一个帧处理器
        processor = new FrameProcessor(this,
                eglManager.getNativeContext(),
                BINARY_GRAPH_NAME,
                INPUT_VIDEO_STREAM_NAME,
                OUTPUT_VIDEO_STREAM_NAME);
        processor.getVideoSurfaceOutput().setFlipY(FLIP_FRAMES_VERTICALLY);

        
        AndroidPacketCreator packetCreator = processor.getPacketCreator();
        Map<String, Packet> inputSidePackets = new HashMap<>();
        inputSidePackets.put(INPUT_NUM_HANDS_SIDE_PACKET_NAME, packetCreator.createInt32(NUM_HANDS));
 //       inputSidePackets.put(
 //               INPUT_MODEL_COMPLEXITY, packetCreator.createInt32(0)); //"modelComplexity": "0" # 0=lite, 1=heavy, not specified=heavy
        processor.setInputSidePackets(inputSidePackets);
        


        // 获取手的关键点模型输出
        processor.addPacketCallback(
                OUTPUT_LANDMARKS_STREAM_NAME,
                (packet) -> {
                    Log.v(TAG, "Received multi-hand landmarks packet.");
                    List<NormalizedLandmarkList> multiHandLandmarks =
                            PacketGetter.getProtoVector(packet, NormalizedLandmarkList.parser());
                    Log.v(
                            TAG,
                            "[TS:"
                                    + packet.getTimestamp()
                                    + "] "
                                    + getMultiHandLandmarksDebugString(multiHandLandmarks));
                    //
                    int numHands = multiHandLandmarks.size();
                    ArrayList<String> sites = new ArrayList<>();  //eh add
                    for (int i = 0; i < numHands; ++i) {
                        String str = GetGestureResult(GestureRecognition(multiHandLandmarks.get(i).getLandmarkList()));
                        sites.add("[" + i + "] " + str);
                        //  Log.d(TAG, "[" + numHands + "] " + str);
                    }
                    showtext.setText(sites.toString());
                    /
                });
        //切换摄像头
        button_change_camera.setOnClickListener(
                v -> {
                    USE_FRONT_CAMERA = !USE_FRONT_CAMERA ;
                    previewDisplayView.setVisibility(View.GONE);
                    converter.close();
                    cameraHelper = null ;

                    converter = new ExternalTextureConverter(eglManager.getContext(),2);
                    converter.setFlipY(FLIP_FRAMES_VERTICALLY);
                    converter.setConsumer(processor);
                    if (PermissionHelper.cameraPermissionsGranted(this)) {
                        startCamera();
                    }

                });

//        button_change_picture_show.setOnClickListener(
//                v->{
//                    int show = previewDisplayView.getVisibility() ;
//                    if(View.GONE  == show ){
//                        previewDisplayView.setVisibility(View.VISIBLE);
//                    }else if (View.VISIBLE == show ){
//                        previewDisplayView.setVisibility(View.GONE);
//                    }
//        });

    }

    private String getMultiHandLandmarksDebugString(List<NormalizedLandmarkList> multiHandLandmarks) {
        if (multiHandLandmarks.isEmpty()) {
            return "No hand landmarks";
        }
        String multiHandLandmarksStr = "Number of hands detected: " + multiHandLandmarks.size() + "\n";
        int handIndex = 0;
        for (NormalizedLandmarkList landmarks : multiHandLandmarks) {
            multiHandLandmarksStr +=
                    "\t#Hand landmarks for hand[" + handIndex + "]: " + landmarks.getLandmarkCount() + "\n";
            int landmarkIndex = 0;
            for (NormalizedLandmark landmark : landmarks.getLandmarkList()) {
                multiHandLandmarksStr +=
                        "\t\tLandmark ["
                                + landmarkIndex
                                + "]: ("
                                + landmark.getX()
                                + ", "
                                + landmark.getY()
                                + ", "
                                + landmark.getZ()
                                + ")\n";
                ++landmarkIndex;
            }
            ++handIndex;
        }
        return multiHandLandmarksStr;
    }

    @Override
    protected void onResume() {
        super.onResume();
        converter = new ExternalTextureConverter(eglManager.getContext(),2);
        converter.setFlipY(FLIP_FRAMES_VERTICALLY);
        converter.setConsumer(processor);
        if (PermissionHelper.cameraPermissionsGranted(this)) {
            startCamera();
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        converter.close();
        previewDisplayView.setVisibility(View.GONE);
        cameraHelper = null ;
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        PermissionHelper.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }

    // 计算最佳的预览大小
    protected Size computeViewSize(int width, int height) {
        return new Size(width, height);
    }

    protected void onPreviewDisplaySurfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        // 设置预览大小
        Size viewSize = computeViewSize(width, height);
        Size displaySize = cameraHelper.computeDisplaySizeFromViewSize(viewSize);
        // 根据是否旋转调整预览图像大小
        boolean isCameraRotated = cameraHelper.isCameraRotated();
        converter.setSurfaceTextureAndAttachToGLContext(
                previewFrameTexture,
                isCameraRotated ? displaySize.getHeight() : displaySize.getWidth(),
                isCameraRotated ? displaySize.getWidth() : displaySize.getHeight());
    }


    private void setupPreviewDisplayView() {
        previewDisplayView.setVisibility(View.GONE);
        ViewGroup viewGroup = findViewById(R.id.preview_display_layout);
        viewGroup.addView(previewDisplayView);

        previewDisplayView
                .getHolder()
                .addCallback(
                        new SurfaceHolder.Callback() {
                            @Override
                            public void surfaceCreated(SurfaceHolder holder) {
                                processor.getVideoSurfaceOutput().setSurface(holder.getSurface());
                            }

                            @Override
                            public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
                                onPreviewDisplaySurfaceChanged(holder, format, width, height);
                            }

                            @Override
                            public void surfaceDestroyed(SurfaceHolder holder) {
                                processor.getVideoSurfaceOutput().setSurface(null);
                            }
                        });
    }

    // 相机启动后事件
    protected void onCameraStarted(SurfaceTexture surfaceTexture) {
        // 显示预览
        previewFrameTexture = surfaceTexture;
        previewDisplayView.setVisibility(View.VISIBLE);
    }

    // 设置相机大小
    protected Size cameraTargetResolution() {
        return null;
    }

    // 启动相机
    public void startCamera() {

        cameraHelper = new CameraXPreviewHelper();

        cameraHelper.setOnCameraStartedListener(this::onCameraStarted);
        CameraHelper.CameraFacing cameraFacing =
                USE_FRONT_CAMERA ? CameraHelper.CameraFacing.FRONT : CameraHelper.CameraFacing.BACK;
        cameraHelper.startCamera(this, cameraFacing, null, cameraTargetResolution());
    }

    // 解析关键点
    private static String getLandmarksDebugString(NormalizedLandmarkList landmarks) {
        int landmarkIndex = 0;
        StringBuilder landmarksString = new StringBuilder();
        for (NormalizedLandmark landmark : landmarks.getLandmarkList()) {
            landmarksString.append("\t\tLandmark[").append(landmarkIndex).append("]: (").append(landmark.getX()).append(", ").append(landmark.getY()).append(", ").append(landmark.getZ()).append(")\n");
            ++landmarkIndex;
        }
        return landmarksString.toString();
    }

    //eh add
    //手势识别
    private  int GestureRecognition( List<NormalizedLandmark> handLandmarkList){
        if (handLandmarkList.size() != 21)
            return -1;


        // 大拇指角度
        // NormalizedLandmark thumb_vec1;
        float thumb_vec1_x =  handLandmarkList.get(0).getX() -  handLandmarkList.get(2).getX() ;
        float thumb_vec1_y =  handLandmarkList.get(0).getY() -  handLandmarkList.get(2).getY() ;

        float thumb_vec2_x =  handLandmarkList.get(3).getX() -  handLandmarkList.get(4).getX() ;
        float thumb_vec2_y =  handLandmarkList.get(3).getY() -  handLandmarkList.get(4).getY() ;
        float thumb_angle = Vector2DAngle(thumb_vec1_x, thumb_vec1_y,thumb_vec2_x, thumb_vec2_y);

        // 食指角度
        float index_vec1_x = handLandmarkList.get(0).getX() -  handLandmarkList.get(6).getX() ;
        float index_vec1_y =  handLandmarkList.get(0).getY() -  handLandmarkList.get(6).getY() ;

        float index_vec2_x = handLandmarkList.get(7).getX() -  handLandmarkList.get(8).getX() ;
        float index_vec2_y =  handLandmarkList.get(7).getY() -  handLandmarkList.get(8).getY() ;

        float index_angle = Vector2DAngle(index_vec1_x, index_vec1_y,index_vec2_x,index_vec2_y);

        // 中指角度
        float middle_vec1_x = handLandmarkList.get(0).getX() -  handLandmarkList.get(10).getX() ;
        float middle_vec1_y =  handLandmarkList.get(0).getY() -  handLandmarkList.get(10).getY() ;

        float middle_vec2_x = handLandmarkList.get(11).getX() -  handLandmarkList.get(12).getX() ;
        float middle_vec2_y =  handLandmarkList.get(11).getY() -  handLandmarkList.get(12).getY() ;

        float middle_angle = Vector2DAngle(middle_vec1_x, middle_vec1_y,middle_vec2_x,middle_vec2_y);

        // 无名指角度
        float ring_vec1_x = handLandmarkList.get(0).getX() -  handLandmarkList.get(14).getX() ;
        float ring_vec1_y =  handLandmarkList.get(0).getY() -  handLandmarkList.get(14).getY() ;

        float ring_vec2_x = handLandmarkList.get(15).getX() -  handLandmarkList.get(16).getX() ;
        float ring_vec2_y =  handLandmarkList.get(15).getY() -  handLandmarkList.get(16).getY() ;

        float ring_angle = Vector2DAngle(ring_vec1_x, ring_vec1_y,ring_vec2_x,ring_vec2_y);

        // 小拇指角度
        float pink_vec1_x = handLandmarkList.get(0).getX() -  handLandmarkList.get(18).getX() ;
        float pink_vec1_y =  handLandmarkList.get(0).getY() -  handLandmarkList.get(18).getY() ;

        float pink_vec2_x = handLandmarkList.get(19).getX() -  handLandmarkList.get(20).getX() ;
        float pink_vec2_y =  handLandmarkList.get(19).getY() -  handLandmarkList.get(20).getY() ;

        float pink_angle = Vector2DAngle(pink_vec1_x, pink_vec1_y,pink_vec2_x,pink_vec2_y);

        // 根据角度判断手势
        float angle_threshold = 65;
        float thumb_angle_threshold = 40;

        int result = -1;
        if ((thumb_angle > thumb_angle_threshold) && (index_angle > angle_threshold) && (middle_angle > angle_threshold) && (ring_angle > angle_threshold) && (pink_angle > angle_threshold))
            result = 9;
        else if ((thumb_angle > 5) && (index_angle < angle_threshold) && (middle_angle > angle_threshold) && (ring_angle > angle_threshold) && (pink_angle > angle_threshold))
            result = 1;
        else if ((thumb_angle > thumb_angle_threshold) && (index_angle < angle_threshold) && (middle_angle < angle_threshold) && (ring_angle > angle_threshold) && (pink_angle > angle_threshold))
            result = 2;
        else if ((thumb_angle > thumb_angle_threshold) && (index_angle < angle_threshold) && (middle_angle < angle_threshold) && (ring_angle < angle_threshold) && (pink_angle > angle_threshold))
            result = 3;
        else if ((thumb_angle > thumb_angle_threshold) && (index_angle < angle_threshold) && (middle_angle < angle_threshold) && (ring_angle < angle_threshold) && (pink_angle < angle_threshold))
            result = 4;
        else if ((thumb_angle < thumb_angle_threshold) && (index_angle < angle_threshold) && (middle_angle < angle_threshold) && (ring_angle < angle_threshold) && (pink_angle < angle_threshold))
            result = 5;
        else if ((thumb_angle < thumb_angle_threshold) && (index_angle > angle_threshold) && (middle_angle > angle_threshold) && (ring_angle > angle_threshold) && (pink_angle < angle_threshold))
            result = 6;
        else if ((thumb_angle < thumb_angle_threshold) && (index_angle > angle_threshold) && (middle_angle > angle_threshold) && (ring_angle > angle_threshold) && (pink_angle > angle_threshold))
            result = 7;
        else if ((thumb_angle > 5) && (index_angle > angle_threshold) && (middle_angle < angle_threshold) && (ring_angle < angle_threshold) && (pink_angle < angle_threshold))
            result = 8;
        else
            result = -1;

        return result;

    }

    private float Vector2DAngle(float x1,float y1,float x2,float y2)
    {
        double PI = 3.141592653;
        double t2 = Math.sqrt(Math.pow(x1, 2) + Math.pow(y1, 2)) * Math.sqrt(Math.pow(x2, 2) + Math.pow(y2, 2));
        double t = (x1 * x2 + y1 * y2) /t2 ;
        double angle = Math.acos(t) * (180 / Math.PI);
        Double D = Double.valueOf(angle);
        float f = D.floatValue();
        return  f;
    }

    private String GetGestureResult(int result)
    {
        String result_str = "无";
        switch (result)
        {
            case 1:
                result_str = "One";
                break;
            case 2:
                result_str = "Two";
                break;
            case 3:
                result_str = "Three";
                break;
            case 4:
                result_str = "Four";
                break;
            case 5:
                result_str = "Five";
                break;
            case 6:
                result_str = "Six";
                break;
            case 7:
                result_str = "ThumbUp";
                break;
            case 8:
                result_str = "Ok";
                break;
            case 9:
                result_str = "Fist";
                break;

            default:
                break;
        }

        return result_str;
    }
}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">
    <LinearLayout
        android:id="@+id/buttons"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        style="?android:attr/buttonBarStyle" android:gravity="center"
        android:orientation="horizontal">
        <Button
            android:id="@+id/button_change_camera"
            android:layout_width="wrap_content"
            style="?android:attr/buttonBarButtonStyle" android:layout_height="wrap_content"
            android:text="切换摄像头" />
        <Button
            android:id="@+id/button_change_picture_show"
            android:layout_width="wrap_content"
            style="?android:attr/buttonBarButtonStyle" android:layout_height="wrap_content"
            android:text="备用" />
    </LinearLayout>

    <FrameLayout
        android:id="@+id/texts"
        android:layout_width="match_parent"
        android:layout_height="wrap_content">
        <TextView
            android:id="@+id/showtext"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:gravity="center"
            android:text="手势结果" />
    </FrameLayout>
    <FrameLayout
        android:id="@+id/preview_display_layout"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <TextView
            android:id="@+id/no_camera_access_view"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:gravity="center"
            android:text="相机连接失败" />
    </FrameLayout>

</LinearLayout>

2：测试结果
在这里插入图片描述

3：后续如需可以上传DEMO工程
下载地址

yunteng521
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
基于mediapipe的手势数字识别
weixin_43917589的博客
06-03 9388
基于mediapipe识别手势所对应的数字(一、二、三、四、五)。 mediapipe的官网 总体思路：mediapipe可以识别手掌的关键点，我的思路是识别单根手指是否弯曲，然后根据五根手指的弯曲程度判断手势所对应的数字。那怎么判断单根手指是否弯曲呢？ 我是根据手指的四个关键点的相对位置。比如识别大拇指的弯曲程度，先计算点4和点3的角度a，再计算点2和点1的角度b，最后计算角度a和角度b的差值的绝对值，如果绝对值小于12度，则认为大拇指是伸直的。其他手指同理。那怎么根据五根手指的弯曲程度判断手势所对应的数
Opencv + MediaPipe -＞ 手势识别
weixin_44686138的博客
03-26 9211
利用OpenCV mediapipe，快速实现简单的手势识别
使用mediapipe训练手指数字识别
科小勒的博客
07-29 1441
本文是从0开始创建一个识别手势的机器学习模型，为了识别手势，采用mediapipe模型，这个模型会返回手指的位置，之后再通过训练一个模型将这些位置分类得到手势
Android实现自定义手势和识别手势的功能
01-04
1. 先完成自定义手势的Activity 1.1 因为需要存储手势文件所以需要声明权限： //读取SD卡权限 //写入SD卡权限 1.2 简单写一个布局文件，其中用到了GestureOverlayView，相当于一个绘制组件。其中有一个重要属性gestureStrokeType，值为sing
Android 相机库CameraView源码解析 (二) : 拍照
朱豪凯的博客
11-26 1809
Android 相机库CameraView源码解析 : 拍照部分
mediapipe学习-手势识别 增加简单手势识别配套DEMO（手加姿态识别）
03-16
mediapipe学习-手势识别 增加简单手势识别 2个DEMO 手加姿态识别 手动编译 https://blog.csdn.net/yunteng521/article/details/126453643
基于Mediapipe的开源手势识别前端应用
最新发布
04-04
人体关键点、人体属性、动作捕捉、手势识别项目；易于使用，用于交流学习
Python手势识别代码 基于MediaPipe手部关键点检测 识别数字手势
06-08
# Python手势识别代码 基于MediaPipe手部关键点检测 识别数字手势 1. 使用MediaPipe库实现手部21个关键点实时检测； 2. 根据手部关键点坐标计算五根手指的角度； 3. 通过手指角度判断手势，例程中包含数字0~9的手势...
基于python mediapipe opencv 的手势识别、手指计数、 完整代码+测试数据 计算机毕设 可直接运行
03-14
mediapipe是谷歌开发并开源的多媒体机器学习模型应用框架。 pip install opencv-python pip install mediapipe 如果你的电脑装有Anaconda，建议选择在Anaconda的环境命令行中进行相应模块的安装，以此构建更具体的...
Python基于mediapipe + opencv的手势识别系统源码
05-06
Python基于mediapipe + opencv的手势识别系统源码 python3.6 运行 project_mp.py
mediapipe中的人脸检测(java)代码初探
teleger的博客
06-02 2307
1.android代码，从创建activity说起. facedetectioncpu（我们暂时讲cpu版本) 下的MainActivity.java文件. a. 毫无疑问，我们来看看. protected void onCreate(Bundle savedInstanceState); 在创建activity的时候，做了些什么工作呢？ super.onCreate(savedInstanceState); setContentView(R.layout.activity.
java手势识别技术_Android基础开发之手势识别
weixin_28956181的博客
02-25 238
由于精确度等原因，手势识别在android中用的并不多，不过这并不妨碍我们来玩玩这个神奇的玩意。在android中要使用手势，先得建立手势库，建立手势库非常简单，新建一个android sample project，建一个android示例工程，然后选择创建的android版本，完了之后看到这个界面：选择gesturebuilder，创建成功之后把它安装到真机上，然后可以在里边添加手势，并给手势命...
基于Mediapipe手势识别
公众号：风景邮递Yuan的博客
05-01 2517
Mediapipe是谷歌开源的跨平台机器学习解决方案，其能够通过摄像头传输的视频数据，实时地检测出人体姿态、面部表情、手势等信息，并以可视化的形式进行展示，为各类应用提供了更加精准和智能的基础支持。2. 数据预处理：利用Mediapipe提供的深度学习模型，在采集到的图像数据上进行特征提取、归一化和降维等操作，以便进行后续的数据分析和模型训练。3. 模型训练：根据采集到的数据和手势分类标签，利用Mediapipe提供的机器学习算法，对手势图像进行分类和识别，输出对应的手势类别。看是否能够正常安装。
手部21个关键点检测+手势识别-[MediaPipe]
热门推荐
weixin_45930948的博客
04-05 5万+
MediaPipe 是一款由 Google Research 开发并开源的多媒体机器学习模型应用框架，可以直接调用其API完成目标检测、人脸检测以及关键点检测等。本篇文章介绍其手部21个关键点检测(win10，python版) MediaPipe官网：https://github.com/google/mediapipe MediaPipe说明文档 安装mediapipe pip install mediapipe 创建手部检测模型 import cv2 import mediapipe as mp mp
基于Mediapipe的Python手势识别项目(手势识别游戏）附项目源码
SOBE_rrr的博客
03-05 1941
基于Mediapipe的Python手势识别项目，手势打蚊子小游戏，附项目源码。
java 手势识别_Flutter学习笔记（33）--GestureDetector手势识别
weixin_39644146的博客
03-05 316
这篇随笔主要记录的学习内容是GestureDetector手势识别，内容包括识别单击、双击、长按、组件拖拽和缩放处理。单击、双击、长按先看下demo，很简单，GestureDetector本身也是一个组件，GestureDetector识别其内部子组件的手势动作，GestureDetector的构造方法内给我们提供了onTap单击、onDoubleTap双击、onLongPress长按的是回调方法...
MediaPipe训练自定义手势识别模型
fukioston的博客
01-19 1705
MediaPipe支持人脸识别、目标检测、图像分类、人像分割、手势识别、文本分类、语音分类。每个模块都有对应的模型，但是原来的模型不一定符合你的需求，比如手势识别中能识别的手势可能不是你想要的手势，这时候你可以自训练一个手势识别模型。
java手势识别技术_Java乔晓松-android中的手势识别的详解
weixin_36310662的博客
02-25 310
对于android中的手势识别，效果如下图所示： 模拟器中有个可以添加手势的工具Gestures Builder，可以添加手势如下图所示： 当添加手势成功后，会在Sdcard上产生保存的手势的文件gestures，如下图所示： 你需要把sdcard中的gestures文件拷贝到项目中去 手势识别的完整的代码如下：package com.example.demo1;import java.util....
关键点检测 MediaPipe实现手势，人体姿态，面部动作估计的用法
guoqingru0311的博客
11-20 551
关键点检测 MediaPipe实现手势，人体姿态，面部动作估计的用法
mediapipe手势识别
05-20
MediaPipe 是 Google 开源的跨平台多媒体框架，其中包含了手势识别的功能。手势识别是一个比较复杂的任务，需要使用深度学习模型进行训练和推断。MediaPipe 中提供了一些已经训练好的手势识别模型，可以直接使用，也可以自己训练自己的模型。 以下是使用 MediaPipe 进行手势识别的流程： 1. 安装 MediaPipe 库和相关依赖 2. 使用 MediaPipe 提供的手势识别模型进行推理，可以使用 MediaPipe Python API 或者 MediaPipe C++ API 3. 在推理过程中，需要将视频或者摄像头捕获的实时图像输入模型，输出模型对应的手势类别和手势框的位置信息。 4. 根据输出结果进行后续处理，如手势识别结果的可视化或者与其他系统的集成。 具体的实现步骤可以参考 MediaPipe 官方文档中的手势识别示例：https://google.github.io/mediapipe/solutions/hands.html

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值