mediapipe学习-手势识别android（3）

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

前言
本章主要讲ANDROID 版本

1：把demo工程拷贝出来
把android 整个目录拷贝出来
在这里插入图片描述

2：用 android studio 打开
1>windows下电极 solutions\create_win_symlinks.bat 生成替换资源文件
用android studio 打开****\solutions
这里用的android studio 4.1.1 打开的，稍微修改了下
在这里插入图片描述

activity_main.xml 增加了一个textview
在这里插入图片描述
修改MainActivity.java 代码如下:

// Copyright 2021 The MediaPipe Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.mediapipe.examples.hands;

import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.os.Bundle;
import android.provider.MediaStore;

import androidx.appcompat.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.FrameLayout;
import android.widget.TextView;

import androidx.activity.result.ActivityResultLauncher;
import androidx.activity.result.contract.ActivityResultContracts;
import androidx.exifinterface.media.ExifInterface;
// ContentResolver dependency
import com.google.mediapipe.formats.proto.LandmarkProto.Landmark;
import com.google.mediapipe.formats.proto.LandmarkProto.NormalizedLandmark;
import com.google.mediapipe.solutioncore.CameraInput;
import com.google.mediapipe.solutioncore.SolutionGlSurfaceView;
import com.google.mediapipe.solutioncore.VideoInput;
import com.google.mediapipe.solutions.hands.HandLandmark;
import com.google.mediapipe.solutions.hands.Hands;
import com.google.mediapipe.solutions.hands.HandsOptions;
import com.google.mediapipe.solutions.hands.HandsResult;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

/** Main activity of MediaPipe Hands app. */
public class MainActivity extends AppCompatActivity {
  private static final String TAG = "MainActivity";

  private Hands hands;
  // Run the pipeline and the model inference on GPU or CPU.
  private static final boolean RUN_ON_GPU = true;

  private enum InputSource {
    UNKNOWN,
    IMAGE,
    VIDEO,
    CAMERA,
  }
  private InputSource inputSource = InputSource.UNKNOWN;

  // Image demo UI and image loader components.
  private ActivityResultLauncher<Intent> imageGetter;
  private HandsResultImageView imageView;
  // Video demo UI and video loader components.
  private VideoInput videoInput;
  private ActivityResultLauncher<Intent> videoGetter;
  // Live camera demo UI and camera components.
  private CameraInput cameraInput;

  private SolutionGlSurfaceView<HandsResult> glSurfaceView;

  private TextView  showtext;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    showtext = findViewById(R.id.showtext);
    setupStaticImageDemoUiComponents();
    setupVideoDemoUiComponents();
    setupLiveDemoUiComponents();
  }

  @Override
  protected void onResume() {
    super.onResume();
    if (inputSource == InputSource.CAMERA) {
      // Restarts the camera and the opengl surface rendering.
      cameraInput = new CameraInput(this);
      cameraInput.setNewFrameListener(textureFrame -> hands.send(textureFrame));
      glSurfaceView.post(this::startCamera);
      glSurfaceView.setVisibility(View.VISIBLE);
    } else if (inputSource == InputSource.VIDEO) {
      videoInput.resume();
    }
  }

  @Override
  protected void onPause() {
    super.onPause();
    if (inputSource == InputSource.CAMERA) {
      glSurfaceView.setVisibility(View.GONE);
      cameraInput.close();
    } else if (inputSource == InputSource.VIDEO) {
      videoInput.pause();
    }
  }

  private Bitmap downscaleBitmap(Bitmap originalBitmap) {
    double aspectRatio = (double) originalBitmap.getWidth() / originalBitmap.getHeight();
    int width = imageView.getWidth();
    int height = imageView.getHeight();
    if (((double) imageView.getWidth() / imageView.getHeight()) > aspectRatio) {
      width = (int) (height * aspectRatio);
    } else {
      height = (int) (width / aspectRatio);
    }
    return Bitmap.createScaledBitmap(originalBitmap, width, height, false);
  }

  private Bitmap rotateBitmap(Bitmap inputBitmap, InputStream imageData) throws IOException {
    int orientation =
        new ExifInterface(imageData)
            .getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
    if (orientation == ExifInterface.ORIENTATION_NORMAL) {
      return inputBitmap;
    }
    Matrix matrix = new Matrix();
    switch (orientation) {
      case ExifInterface.ORIENTATION_ROTATE_90:
        matrix.postRotate(90);
        break;
      case ExifInterface.ORIENTATION_ROTATE_180:
        matrix.postRotate(180);
        break;
      case ExifInterface.ORIENTATION_ROTATE_270:
        matrix.postRotate(270);
        break;
      default:
        matrix.postRotate(0);
    }
    return Bitmap.createBitmap(
        inputBitmap, 0, 0, inputBitmap.getWidth(), inputBitmap.getHeight(), matrix, true);
  }

  /** Sets up the UI components for the static image demo. */
  private void setupStaticImageDemoUiComponents() {
    // The Intent to access gallery and read images as bitmap.
    imageGetter =
        registerForActivityResult(
            new ActivityResultContracts.StartActivityForResult(),
            result -> {
              Intent resultIntent = result.getData();
              if (resultIntent != null) {
                if (result.getResultCode() == RESULT_OK) {
                  Bitmap bitmap = null;
                  try {
                    bitmap =
                        downscaleBitmap(
                            MediaStore.Images.Media.getBitmap(
                                this.getContentResolver(), resultIntent.getData()));
                  } catch (IOException e) {
                    Log.e(TAG, "Bitmap reading error:" + e);
                  }
                  try {
                    InputStream imageData =
                        this.getContentResolver().openInputStream(resultIntent.getData());
                    bitmap = rotateBitmap(bitmap, imageData);
                  } catch (IOException e) {
                    Log.e(TAG, "Bitmap rotation error:" + e);
                  }
                  if (bitmap != null) {
                    hands.send(bitmap);
                  }
                }
              }
            });
    Button loadImageButton = findViewById(R.id.button_load_picture);
    loadImageButton.setOnClickListener(
        v -> {
          if (inputSource != InputSource.IMAGE) {
            stopCurrentPipeline();
            setupStaticImageModePipeline();
          }
          // Reads images from gallery.
          Intent pickImageIntent = new Intent(Intent.ACTION_PICK);
          pickImageIntent.setDataAndType(MediaStore.Images.Media.INTERNAL_CONTENT_URI, "image/*");
          imageGetter.launch(pickImageIntent);
        });
    imageView = new HandsResultImageView(this);
  }

  /** Sets up core workflow for static image mode. */
  private void setupStaticImageModePipeline() {
    this.inputSource = InputSource.IMAGE;
    // Initializes a new MediaPipe Hands solution instance in the static image mode.
    hands =
        new Hands(
            this,
            HandsOptions.builder()
                .setStaticImageMode(true)
                .setMaxNumHands(2)
                .setRunOnGpu(RUN_ON_GPU)
                .build());

    // Connects MediaPipe Hands solution to the user-defined HandsResultImageView.
    hands.setResultListener(
        handsResult -> {
          logWristLandmark(handsResult, /*showPixelValues=*/ true);
          imageView.setHandsResult(handsResult);
          runOnUiThread(() -> imageView.update());
        });
    hands.setErrorListener((message, e) -> Log.e(TAG, "MediaPipe Hands error:" + message));

    // Updates the preview layout.
    FrameLayout frameLayout = findViewById(R.id.preview_display_layout);
    frameLayout.removeAllViewsInLayout();
    imageView.setImageDrawable(null);
    frameLayout.addView(imageView);
    imageView.setVisibility(View.VISIBLE);
  }

  /** Sets up the UI components for the video demo. */
  private void setupVideoDemoUiComponents() {
    // The Intent to access gallery and read a video file.
    videoGetter =
        registerForActivityResult(
            new ActivityResultContracts.StartActivityForResult(),
            result -> {
              Intent resultIntent = result.getData();
              if (resultIntent != null) {
                if (result.getResultCode() == RESULT_OK) {
                  glSurfaceView.post(
                      () ->
                          videoInput.start(
                              this,
                              resultIntent.getData(),
                              hands.getGlContext(),
                              glSurfaceView.getWidth(),
                              glSurfaceView.getHeight()));
                }
              }
            });
    Button loadVideoButton = findViewById(R.id.button_load_video);
    loadVideoButton.setOnClickListener(
        v -> {
          stopCurrentPipeline();
          setupStreamingModePipeline(InputSource.VIDEO);
          // Reads video from gallery.
          Intent pickVideoIntent = new Intent(Intent.ACTION_PICK);
          pickVideoIntent.setDataAndType(MediaStore.Video.Media.INTERNAL_CONTENT_URI, "video/*");
          videoGetter.launch(pickVideoIntent);
        });
  }

  /** Sets up the UI components for the live demo with camera input. */
  private void setupLiveDemoUiComponents() {
    Button startCameraButton = findViewById(R.id.button_start_camera);
    startCameraButton.setOnClickListener(
        v -> {
          if (inputSource == InputSource.CAMERA) {
            return;
          }
          stopCurrentPipeline();
          setupStreamingModePipeline(InputSource.CAMERA);
        });
  }

  /** Sets up core workflow for streaming mode. */
  private void setupStreamingModePipeline(InputSource inputSource) {
    this.inputSource = inputSource;
    // Initializes a new MediaPipe Hands solution instance in the streaming mode.
    hands =
        new Hands(
            this,
            HandsOptions.builder()
                .setStaticImageMode(false)
                .setMaxNumHands(2)
                .setRunOnGpu(RUN_ON_GPU)
                .build());
    hands.setErrorListener((message, e) -> Log.e(TAG, "MediaPipe Hands error:" + message));

    if (inputSource == InputSource.CAMERA) {
      cameraInput = new CameraInput(this);
      cameraInput.setNewFrameListener(textureFrame -> hands.send(textureFrame));
    } else if (inputSource == InputSource.VIDEO) {
      videoInput = new VideoInput(this);
      videoInput.setNewFrameListener(textureFrame -> hands.send(textureFrame));
    }

    // Initializes a new Gl surface view with a user-defined HandsResultGlRenderer.
    glSurfaceView =
        new SolutionGlSurfaceView<>(this, hands.getGlContext(), hands.getGlMajorVersion());
    glSurfaceView.setSolutionResultRenderer(new HandsResultGlRenderer());
    glSurfaceView.setRenderInputImage(true);
    hands.setResultListener(
        handsResult -> {
          logWristLandmark(handsResult, /*showPixelValues=*/ false);
          glSurfaceView.setRenderData(handsResult);
          glSurfaceView.requestRender();
        });

    // The runnable to start camera after the gl surface view is attached.
    // For video input source, videoInput.start() will be called when the video uri is available.
    if (inputSource == InputSource.CAMERA) {
      glSurfaceView.post(this::startCamera);
    }

    // Updates the preview layout.
    FrameLayout frameLayout = findViewById(R.id.preview_display_layout);
    imageView.setVisibility(View.GONE);
    frameLayout.removeAllViewsInLayout();
    frameLayout.addView(glSurfaceView);
    glSurfaceView.setVisibility(View.VISIBLE);
    frameLayout.requestLayout();
  }

  private void startCamera() {
    cameraInput.start(
        this,
        hands.getGlContext(),
        CameraInput.CameraFacing.FRONT,
        glSurfaceView.getWidth(),
        glSurfaceView.getHeight());
  }

  private void stopCurrentPipeline() {
    if (cameraInput != null) {
      cameraInput.setNewFrameListener(null);
      cameraInput.close();
    }
    if (videoInput != null) {
      videoInput.setNewFrameListener(null);
      videoInput.close();
    }
    if (glSurfaceView != null) {
      glSurfaceView.setVisibility(View.GONE);
    }
    if (hands != null) {
      hands.close();
    }
  }

  private void logWristLandmark(HandsResult result, boolean showPixelValues) {
    if (result.multiHandLandmarks().isEmpty()) {
      return;
    }
    NormalizedLandmark wristLandmark =
        result.multiHandLandmarks().get(0).getLandmarkList().get(HandLandmark.WRIST);
    // For Bitmaps, show the pixel values. For texture inputs, show the normalized coordinates.
    if (showPixelValues) {
      int width = result.inputBitmap().getWidth();
      int height = result.inputBitmap().getHeight();
      Log.i(
          TAG,
          String.format(
              "MediaPipe Hand wrist coordinates (pixel values): x=%f, y=%f",
              wristLandmark.getX() * width, wristLandmark.getY() * height));
    } else {
      Log.i(
          TAG,
          String.format(
              "MediaPipe Hand wrist normalized coordinates (value range: [0, 1]): x=%f, y=%f",
              wristLandmark.getX(), wristLandmark.getY()));
    }
    if (result.multiHandWorldLandmarks().isEmpty()) {
      return;
    }
    Landmark wristWorldLandmark =
        result.multiHandWorldLandmarks().get(0).getLandmarkList().get(HandLandmark.WRIST);
    Log.i(
        TAG,
        String.format(
            "MediaPipe Hand wrist world coordinates (in meters with the origin at the hand's"
                + " approximate geometric center): x=%f m, y=%f m, z=%f m",
            wristWorldLandmark.getX(), wristWorldLandmark.getY(), wristWorldLandmark.getZ()));

    int numHands = result.multiHandLandmarks().size();
    ArrayList<String> sites = new ArrayList<>();  //eh add
    for (int i = 0; i < numHands; ++i) {
      String str = GetGestureResult(GestureRecognition(result.multiHandLandmarks().get(i).getLandmarkList()));
      sites.add("[" + i + "] " + str);
    //  Log.d(TAG, "[" + numHands + "] " + str);
    }
    showtext.setText(sites.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 > 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;
      default:
        break;
    }

    return result_str;
  }

}

3:编译
android 支持 选择图片 / 视屏 /摄像头（代码里写的是调用前置）

4:后面继续补充其他实例
感觉比 seetaface 靠谱多了

yunteng521
关注
专栏目录
mediapipemultihandstrackingapp:通过Mediapipe进行手势识别
05-10
通过Android上的Mediapipe进行手势识别 看到这些是使用Android档案（AAR）和Gradle，手势识别的想法来自于 ， 如果有帮助，请给我个星星。
基于MediaPipe的手势识别 --安卓部分
weixin_46124467的博客
12-06 4473
基于MediaPipe的手势识别 --安卓部分 mediapipe网址：可能会有点儿慢 https://google.github.io/mediapipe/solutions/hands.html#static_image_mode 简单介绍一下mediaPipe，他就是一个集成好的包括人脸关键位点识别、身体关键位点识别、手部关键位点识别的一个包或者库，直接调用就能够得到它的关键位点信息，以手部关键位点为例子： 通过检测人手部得到21个点的一个列表如下 [[x0,y0,z0],[x1,y1,z1],…
基于mediapipe动作捕捉的控制游戏插件
最新发布
weixin_48274680的博客
10-06 1099
在传统的游戏控制中，玩家通常依赖键盘、鼠标或者游戏手柄来进行操作。然而，随着计算机视觉技术的发展，越来越多的研究者和开发者开始探索通过手势和动作来操控游戏的可能性。本文介绍的游戏控制插件就是基于这个理念开发的，利用mediapipe 动作捕捉算法，识别动作模式，允许玩家通过手势和头部动作控制游戏中的角色移动、跳跃、攻击等操作，为游戏提供了一种更加自然和沉浸式的控制方式。
mediapipe学习-手势识别生成Android版AAR(4)
yunteng521的博客
08-14 2380
mediapipe学习-手势识别 生成Android版AAR（4）
【Android】AndroidStudio配置Mediapipe项目
qq_51973991的博客
01-11 1059
项目构建过程中还会报一个找不到jar包的异常（Could not find tasks-vision-0.10.0.jar (com.google.mediapipe:tasks-vision:0.），需要对之前添加的仓库源进行注释，注释完之后再次 Sync Now更新之后解决问题。打开项目中的gradle-wrapper.properties文件，更改gradle的下载地址，我这里更改的是腾讯源。（3）修改mediapipe项目的部分文件，提升配置速度（换源）mediapipe官网。
Mediapipe 手势识别
热门推荐
Zcc的博客
04-29 1万+
Mediapipe 实现手势识别（石头剪刀布）封装函数（可跳过）手势判断完整代码相关连接 环境：python3.8，pycharm2020 硬件：罗技c505e 基于前面一篇文章，我们已经能够实现手关键点的信息的提取，通过对这些信息的处理我们可以很轻松地进行手势识别。（完整代码见文末） 先看一波效果图: 封装函数（可跳过） 为方便调用，先将之前关键点提取相关函数分装成类 import cv2 import mediapipe as mp import time import math class ha
mediapipe学习-手势识别 增加简单手势识别配套DEMO（手加姿态识别）
03-16
mediapipe学习-手势识别 增加简单手势识别 2个DEMO 手加姿态识别 手动编译 https://blog.csdn.net/yunteng521/article/details/126453643
基于Mediapipe的开源手势识别前端应用
04-04
本项目“基于Mediapipe的开源手势识别前端应用”就是这样一个优秀的实例，旨在促进交流和学习。 Mediapipe是谷歌推出的一个实时处理图形流水线框架，它能够高效地解决多种计算机视觉问题。该框架支持多种平台，包括...
Android实现自定义手势和识别手势的功能
01-04
1. 先完成自定义手势的Activity 1.1 因为需要存储手势文件所以需要声明权限： <uses android:name=android.permission.READ_EXTERNAL_STORAGE> //读取SD卡权限 <uses android:name=android.permission.WRITE_...
基于Mediapipe的开源手势认知别前应用基于Mediapipe的开源手势识别前端应用_AutoHotkey_HTML.zip
05-01
在手势识别应用中，可能包含预处理步骤（如图像校正、裁剪）、特征提取、分类器（如深度学习模型）以及后处理步骤。 6. **实时性**：由于Mediapipe设计用于实时处理，因此此应用可以实现实时手势跟踪和识别，为用户...
Mediapipe框架在Android上的使用源码
01-05
在Android平台上使用Mediapipe，可以让我们在手机应用中实现诸如手势识别等高级功能。 Mediapipe的工作原理基于“管道”概念，它将各种计算任务分解为一系列处理单元，称为“算子”（Graph Nodes）。这些算子通过...
Android-mediapipe.zip
09-17
Android-mediapipe.zip,MediaPipe是一个跨平台框架，用于构建多模式应用机器学习管道,安卓系统是谷歌在2008年设计和制造的。操作系统主要写在爪哇，C和C 的核心组件。它是在linux内核之上构建的，具有安全性优势。
基于OpenCV+MediaPipe的手势识别（数字、石头剪刀布等手势识别）
03-03
基于OpenCV+MediaPipe的手势识别（数字、石头剪刀布等手势识别） 可识别左右手，共定义了15种手势，可以自行增加 https://blog.csdn.net/weixin_53403301/article/details/123232435
Mediapipe手势识别
no1xiaoqianqian的博客
09-27 5876
Mediapipe手势识别及原文阅读
Mediapipe框架在Android上的使用
夜雨飘零
07-08 1万+
MediaPipe是用于构建跨平台多模态应用ML管道的框架，其包括快速ML推理，经典计算机视觉和媒体内容处理（如视频解码）。下面是用于对象检测与追踪的MediaPipe示例图，它由4个计算节点组成：PacketResampler计算器；先前发布的ObjectDetection子图；围绕上述BoxTrakcing子图的ObjectTracking子图；以及绘制可视化效果的Renderer子图。
基于MediaPipe的手势识别
K_AAbb的博客
05-27 1798
1.HandTrackingMin.py import cv2 import mediapipe as mp import time cap = cv2.VideoCapture(0) mpHands = mp.solutions.hands hands = mpHands.Hands() mpDraw = mp.solutions.drawing_utils pTime = 0 cTime = 0 while True: success, img = cap.read() imgR
基于mediapipe的手势识别
qq_24946843的博客
07-14 1447
安装opencv：pip install opencv-python。安装mediapipe：pip install mediapipe。
mediapipe学习-手势识别android 用aar（5）
yunteng521的博客
08-17 1939
mediapipe学习-手势识别android 用aar（5）
Python | 基于Mediapipe框架的手势识别系统
鷾
01-07 1969
基于Mediapipe框架的手势识别系统
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值