windows 基于 MediaPipe 实现 Holistic

置顶 已于 2022-12-12 10:46:51 修改
阅读量1.7k 收藏 7
点赞数 1
分类专栏： CV 文章标签： 程序人生 mediapipe
于 2022-12-11 22:00:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haiyangyunbao813/article/details/128271295
版权

在这里插入图片描述
主页: https://google.github.io/mediapipe/solutions/holistic.html

MediaPipe Holistic pipelines 集成了姿势、面部和手部组件的独立模型，每个组件都针对其特定领域进行了优化，每个组件的推断输入图不同。

MediaPipe Holistic 首先通过 BlazePose 的姿势检测器和后续的关键点模型来估计人的姿势。然后，利用推断出的姿势关键点，为每只手和脸部推导出三个感兴趣区域（ROI）裁剪，并采用 re-crop 模型来改进 ROI

然后，pipelines 将全分辨率输入帧上裁剪这些 ROI，并应用特定任务的模型来估计它们对应的关键点。最后，将所有关键点与姿势模型的关键点合并，得出全部 540 多个关键点。

实现过程 🚀​

编译demo

  1. bazel build -c opt --define MEDIAPIPE_DISABLE_GPU=1 --action_env PYTHON_BIN_PATH="C:xxx//python.exe" mediapipe/examples/desktop/holistic_tracking:holistic_tracking_cpu --verbose_failures

bazel-bin\mediapipe\examples\desktop\holistic_tracking\holistic_tracking_cpu --calculator_graph_config_file=mediapipe/graphs/holistic_tracking/holistic_tracking_cpu.pbtxt

  2. 如果运行成功，则默认会调用摄像头

编写测试demo

  1. 环境配置参考:

  2. 修改 mediapipe\examples\desktop\holistic_tracking 中 BUILD

  3. 增加个测试程序节点

    cc_binary(
    name = "holistic_tracking_sample",
    srcs = ["main.cpp","holistic_detect.h","holistic_detect.cpp"],
    # linkshared=True,
    deps = [
        "//mediapipe/graphs/holistic_tracking:holistic_tracking_cpu_graph_deps",
    ],
)

  4. holistic_detect.h

    #ifndef _HOLISTIC_DETECT_H_
#define _HOLISTIC_DETECT_H_

#include <cstdlib>
#include "absl/flags/flag.h"
#include "absl/flags/parse.h"
#include "mediapipe/framework/calculator_framework.h"
#include "mediapipe/framework/formats/image_frame.h"
#include "mediapipe/framework/formats/image_frame_opencv.h"
#include "mediapipe/framework/port/file_helpers.h"
#include "mediapipe/framework/port/opencv_highgui_inc.h"
#include "mediapipe/framework/port/opencv_imgproc_inc.h"
#include "mediapipe/framework/port/opencv_video_inc.h"
#include "mediapipe/framework/port/parse_text_proto.h"
#include "mediapipe/framework/port/status.h"
#include "mediapipe/framework/formats/detection.pb.h"
#include "mediapipe/framework/formats/landmark.pb.h"
#include "mediapipe/framework/formats/rect.pb.h"
#include "mediapipe/framework/formats/classification.pb.h"
#include "mediapipe/framework/port/ret_check.h"

namespace mp {

	using holistic_callback_t = std::function<void()>;

	class HolisticDetect
	{
	public:
		int initModel(const char* model_path) noexcept;
		int detectVideoCamera(holistic_callback_t call);
		int detectVideo(const char* video_path, int show_image, holistic_callback_t call);
		int detectVideo();
		int release();
	private:
		absl::Status initGraph(const char* model_path);
		absl::Status runMPPGraphVideo(const char* video_path, int show_image, holistic_callback_t call);
		absl::Status releaseGraph();

		void showFaceLandmarks(cv::Mat& image);
		void showPoseLandmarks(cv::Mat& image);
		void showLHandLandmarks(cv::Mat& image);
		void showRHandLandmarks(cv::Mat& image);

		const char* kInputStream = "input_video";
		const char* kOutputStream = "output_video";
		const char* kWindowName = "MediaPipe";
		const char* kOutputLandmarks = "face_landmarks";
		const char* kOutputPoseLandmarks = "pose_landmarks";
		const char* kOutputLHandLandmarks = "left_hand_landmarks";
		const char* kOutputRHandLandmarks = "right_hand_landmarks";

		bool init_ = false;
		mediapipe::CalculatorGraph graph_;

		const float kMinFloat = std::numeric_limits<float>::lowest();
		const float kMaxFloat = std::numeric_limits<float>::max();

		std::unique_ptr<mediapipe::OutputStreamPoller> pPoller_;
		std::unique_ptr<mediapipe::OutputStreamPoller> pPollerFaceLandmarks_;
		std::unique_ptr<mediapipe::OutputStreamPoller> pPollerPoseLandmarks_;
		std::unique_ptr<mediapipe::OutputStreamPoller> pPollerLHandLandmarks_;
		std::unique_ptr<mediapipe::OutputStreamPoller> pPollerRHandLandmarks_;
	};
}

#endif

  5. holistic_detect.cpp

    #include "holistic_detect.h"
using namespace mp;

int HolisticDetect::initModel(const char* model_path) noexcept {
	absl::Status run_status = initGraph(model_path);
	if (!run_status.ok())
		return -1;
	init_ = true;
	return  1;
}

int HolisticDetect::detectVideoCamera(holistic_callback_t call) {
	if (!init_)
		return -1;

	absl::Status run_status = runMPPGraphVideo("", true, call);
	return run_status.ok() ? 1 : -1;
}

int HolisticDetect::detectVideo(const char* video_path, int show_image, holistic_callback_t call) {
	if (!init_)
		return -1;

	absl::Status run_status = runMPPGraphVideo(video_path, show_image, call);
	return run_status.ok() ? 1 : -1;
}

int HolisticDetect::detectVideo() {
	if (!init_)
		return -1;
	absl::Status run_status = runMPPGraphVideo("", 1, nullptr);
	return run_status.ok() ? 1 : -1;
}

int HolisticDetect::release() {
	absl::Status run_status = releaseGraph();
	return run_status.ok() ? 1 : -1;
}

absl::Status HolisticDetect::initGraph(const char* model_path) {

	std::string calculator_graph_config_contents;
	MP_RETURN_IF_ERROR(mediapipe::file::GetContents(model_path, &calculator_graph_config_contents));
	mediapipe::CalculatorGraphConfig config =
		mediapipe::ParseTextProtoOrDie<mediapipe::CalculatorGraphConfig>(
			calculator_graph_config_contents);
	MP_RETURN_IF_ERROR(graph_.Initialize(config));
	auto sop = graph_.AddOutputStreamPoller(kOutputStream);
	assert(sop.ok());
	pPoller_ = std::make_unique<mediapipe::OutputStreamPoller>(std::move(sop.value()));

	// 脸部特征
	mediapipe::StatusOrPoller faceLandmark = graph_.AddOutputStreamPoller(kOutputLandmarks);
	assert(faceLandmark.ok());
	pPollerFaceLandmarks_ = std::make_unique<mediapipe::OutputStreamPoller>(std::move(faceLandmark.value()));

	// 姿态特征
	mediapipe::StatusOrPoller poseLandmark = graph_.AddOutputStreamPoller(kOutputPoseLandmarks);
	assert(poseLandmark.ok());
	pPollerPoseLandmarks_ = std::make_unique<mediapipe::OutputStreamPoller>(std::move(poseLandmark.value()));

	// 左手特征点
	mediapipe::StatusOrPoller leftHandLandmark = graph_.AddOutputStreamPoller(kOutputLHandLandmarks);
	assert(leftHandLandmark.ok());
	pPollerLHandLandmarks_ = std::make_unique<mediapipe::OutputStreamPoller>(std::move(leftHandLandmark.value()));

	// 右手特征点
	mediapipe::StatusOrPoller rightHandLandmark = graph_.AddOutputStreamPoller(kOutputRHandLandmarks);
	assert(rightHandLandmark.ok());
	pPollerRHandLandmarks_ = std::make_unique<mediapipe::OutputStreamPoller>(std::move(rightHandLandmark.value()));

	MP_RETURN_IF_ERROR(graph_.StartRun({}));
	std::cout << "======= graph_ StartRun success ============" << std::endl;
	return absl::OkStatus();
}

void HolisticDetect::showFaceLandmarks(cv::Mat& image) {
	mediapipe::Packet packet_landmarks;
	if (pPollerFaceLandmarks_->QueueSize() == 0 || !pPollerFaceLandmarks_->Next(&packet_landmarks))
		return;

	//  468 face landmark
	auto& output_landmarks = packet_landmarks.Get<mediapipe::NormalizedLandmarkList>();
	for (int i = 0; i < output_landmarks.landmark_size(); ++i)
	{
		const mediapipe::NormalizedLandmark landmark = output_landmarks.landmark(i);
		float x = landmark.x() * image.cols;
		float y = landmark.y() * image.rows;
		//cv::circle(image, cv::Point(x, y), 2, cv::Scalar(0, 255, 0));
		// todo
		// ...
	}
}

void HolisticDetect::showPoseLandmarks(cv::Mat& image) {
	mediapipe::Packet packet_landmarks;
	if (pPollerPoseLandmarks_->QueueSize() == 0 || !pPollerPoseLandmarks_->Next(&packet_landmarks))
		return;

	//  33 pose landmark
	auto& output_landmarks = packet_landmarks.Get<mediapipe::NormalizedLandmarkList>();
	for (int i = 0; i < output_landmarks.landmark_size(); ++i)
	{
		const mediapipe::NormalizedLandmark landmark = output_landmarks.landmark(i);
		float x = landmark.x() * image.cols;
		float y = landmark.y() * image.rows;
		//cv::circle(image, cv::Point(x, y), 2, cv::Scalar(0, 255, 0));
		// todo
		// ...
	}
}

void HolisticDetect::showLHandLandmarks(cv::Mat& image) {
	mediapipe::Packet packet_landmarks;
	if (pPollerLHandLandmarks_->QueueSize() == 0 || !pPollerLHandLandmarks_->Next(&packet_landmarks))
		return;
	//  21 left hand landmark
	auto& output_landmarks = packet_landmarks.Get<mediapipe::NormalizedLandmarkList>();
	for (int i = 0; i < output_landmarks.landmark_size(); ++i)
	{
		const mediapipe::NormalizedLandmark landmark = output_landmarks.landmark(i);
		float x = landmark.x() * image.cols;
		float y = landmark.y() * image.rows;
		//cv::circle(image, cv::Point(x, y), 2, cv::Scalar(0, 255, 0));
		// todo
		// ...
	}
}

void HolisticDetect::showRHandLandmarks(cv::Mat& image) {
	mediapipe::Packet packet_landmarks;
	if (pPollerRHandLandmarks_->QueueSize() == 0 || !pPollerRHandLandmarks_->Next(&packet_landmarks))
		return;
	//  21 right hand landmark
	auto& output_landmarks = packet_landmarks.Get<mediapipe::NormalizedLandmarkList>();
	for (int i = 0; i < output_landmarks.landmark_size(); ++i)
	{
		const mediapipe::NormalizedLandmark landmark = output_landmarks.landmark(i);
		float x = landmark.x() * image.cols;
		float y = landmark.y() * image.rows;
		//cv::circle(image, cv::Point(x, y), 2, cv::Scalar(0, 255, 0));
		// todo
		// ...
	}
}

absl::Status HolisticDetect::runMPPGraphVideo(const char* video_path, int show_image, holistic_callback_t call) {
	cv::VideoCapture capture(video_path);
	RET_CHECK(capture.isOpened());
#if (CV_MAJOR_VERSION >= 3) && (CV_MINOR_VERSION >= 2)
	capture.set(cv::CAP_PROP_FRAME_WIDTH, 640);
	capture.set(cv::CAP_PROP_FRAME_HEIGHT, 480);
	capture.set(cv::CAP_PROP_FPS, 30);
#endif
	int tmp = 0;
	bool grab_frames = true;
	while (grab_frames) {
		// Capture opencv camera or video frame.
		cv::Mat camera_frame_raw;
		capture >> camera_frame_raw;
		if (camera_frame_raw.empty())
			break;

		cv::Mat camera_frame;
		cv::cvtColor(camera_frame_raw, camera_frame, cv::COLOR_BGR2RGB);
		cv::flip(camera_frame, camera_frame, /*flipcode=HORIZONTAL*/ 1);

		// Wrap Mat into an ImageFrame.
		auto input_frame = absl::make_unique<mediapipe::ImageFrame>(
			mediapipe::ImageFormat::SRGB, camera_frame.cols, camera_frame.rows,
			mediapipe::ImageFrame::kDefaultAlignmentBoundary);
		cv::Mat input_frame_mat = mediapipe::formats::MatView(input_frame.get());
		camera_frame.copyTo(input_frame_mat);

		// Send image packet into the graph.
		size_t frame_timestamp_us =
			(double)cv::getTickCount() / (double)cv::getTickFrequency() * 1e6;

		MP_RETURN_IF_ERROR(graph_.AddPacketToInputStream(
			kInputStream, mediapipe::Adopt(input_frame.release())
			.At(mediapipe::Timestamp(frame_timestamp_us))));

		// Get the graph result packet, or stop if that fails.
		mediapipe::Packet packet;
		if (!pPoller_->Next(&packet)) break;

		showFaceLandmarks(camera_frame);
		showPoseLandmarks(camera_frame);
		showLHandLandmarks(camera_frame);
		showRHandLandmarks(camera_frame);

		if (show_image) {
			auto& output_frame = packet.Get<mediapipe::ImageFrame>();
			// Convert back to opencv for display or saving.
			cv::Mat output_frame_mat = mediapipe::formats::MatView(&output_frame);
			cv::cvtColor(output_frame_mat, output_frame_mat, cv::COLOR_RGB2BGR);

			cv::imshow(kWindowName, output_frame_mat);
			cv::waitKey(1);
			/*	cv::Mat output_frame_mat;
				cv::cvtColor(camera_frame, output_frame_mat, cv::COLOR_RGB2BGR);
				cv::imwrite(cv::format("out_image/%d.jpg", tmp++), output_frame_mat);*/
		}
	}
	if (show_image)
		cv::destroyWindow(kWindowName);
	return absl::OkStatus();
}

absl::Status HolisticDetect::releaseGraph() {
	MP_RETURN_IF_ERROR(graph_.CloseInputStream(kInputStream));
	MP_RETURN_IF_ERROR(graph_.CloseInputStream(kOutputLandmarks));
	return graph_.WaitUntilDone();
}

  6. main.cpp

    #include "holistic_detect.h"
using namespace mp;
HolisticDetect holisticDetect_;
void call() {
}
int main(int argc, char* argv[]) {
	std::cout << "======= holistic ============" << std::endl;
	const char* model = argv[1];
	const char* video_path = argv[2];
	int isShow = 1;
	int res = holisticDetect_.initModel(model);
	if (res < 0) {
		std::cout << "======= initModel error ============" << std::endl;
		return -1;
	}
	res = holisticDetect_.detectVideo(video_path, isShow , call);
	if (res < 0)
		return -1;
	holisticDetect_.release();
	return 0;
}

  7. 编译

    bazel build -c opt --define MEDIAPIPE_DISABLE_GPU=1 --action_env PYTHON_BIN_PATH="C://xx//python.exe" mediapipe/examples/desktop/holistic_tracking:holistic_tracking_sample --verbose_failures

  8. 运行

    bazel-bin\mediapipe\examples\desktop\holistic_tracking\holistic_tracking_sample "mediapipe/graphs/holistic_tracking/holistic_tracking_cpu.pbtxt" "video/test.mp4"

  9. 运行成功， 则可获取人脸面部 468 个特征点 ，左手 21 个特征点 ， 右手 21 个特征点 ，姿态 33 个特征点。

在这里插入图片描述 在这里插入图片描述 在这里插入图片描述 在这里插入图片描述

其他模块 ☀️

  1. IRIS: https://blog.csdn.net/haiyangyunbao813/article/details/122225445?spm=1001.2014.3001.5502
  2. Pose: https://blog.csdn.net/haiyangyunbao813/article/details/119192951?spm=1001.2014.3001.5502
  3. Hand: https://blog.csdn.net/haiyangyunbao813/article/details/122464972?spm=1001.2014.3001.5502
  4. 其他待续…

青春不过几届世界杯

输赢并不是足球的全部 , 真正的热爱或许是笑着庆祝, 哭着鼓掌 。加油马儿，愿 2026 再战一届。 🌟​🌟​🌟​🌟​🌟​

在这里插入图片描述

J ..
关注
专栏目录
MediaPipe Holistic--Google面部，手势与姿势预测算法
人工智能研究所的博客
12-21 1563
今天，我们很高兴宣布推出，它是针对这一挑战的解决方案，它提供了一种新颖的，最新的人体姿势拓扑结构，可以解锁新颖的用例。MediaPipe Holistic由新的流水线组成，这些流水线具有经过优化的姿势，和组件，每个组件均实时运行，其推理后端之间的内存传输最少，并增加了对这三个组件的互换性的支持，具体取决于质量/速度的权衡。另外，姿势模型的输入帧的分辨率足够低，以致于脸部和手部的最终ROI仍然不够准确，无法指导那些区域的重新裁剪，这需要精确的输入裁剪来保持轻巧。流水线的多阶段性质提供了另外两个性能优势。
基于Mediapipe+Opencv实现手势检测
风吹落叶的博客
01-07 4218
基于Mediapipe+Opencv实现手势检测 一、前言 想实现一下姿态识别的时候，感觉手势识别也蛮重要的就过来顺便实现一下。 下面是一些国内的pip源，有需要可自取 阿里云 http://mirrors.aliyun.com/pypi/simple/ 中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/ 豆瓣(douban) http://pypi.douban.com/simple/ 清华大学 https://pypi.tuna.tsinghua.edu.cn
MediaPipe Holisitic：实现端侧人脸手势姿态同时估计
谷歌开发者
12-29 4228
文 / Ivan Grishchenko 和 Valentin Bazarevsky，Google Research 研究工程师在移动设备上实时且同时感知人体姿态、面部特征点和进行手部追...
基于MediaPipe的全身骨骼关键点实时检测+手部关键点角度检测
最新发布
weixin_62921094的博客
07-30 845
人体骨骼关键点检测
Mediapipe-Holistic-Tracking
03-25
Mediapipe整体跟踪 使用Google的mediapipe python API跟踪视频的整体情况。 用法 $ python app.py -i <input video path> -o <output> -f <path>
windows10编译mediapipe C++ 版本 新鲜出炉保姆级别教程
qq_58611650的博客
07-18 2554
windows10编译mediapipe C++ 版本 新鲜出炉保姆级别教程
windows 基于 MediaPipe 实现 PoseTracking
J。
07-29 9388
 MediaPipe是用于构建跨平台多模态应用ML管道的框架，其包括快速ML推理，经典计算机视觉和媒体内容处理（如视频解码）。在2019年6月举行的CVPR大会，MeidaPipe正式开源，版本是v0.5.0。自那以后，谷歌陆续发布了一系列的ML管道示例。  日前，谷歌撰文介绍了又一个MediaPipe示例：Object Detection and Tracking。谷歌首次描述了新发布的Box Tracking解决方案，并解释了它是如何与Object Detection结合并提供一个对象检测与追踪系统。.
Windows下如何运行mediapipe（极简版）
深度学习
11-16 1628
运行mediapipe的极简方法
mediapipe 通过holistic输出2d坐标
05-30
Mediapipe Holistic 模型可以输出人体关键点的 2D 像素坐标。具体来说，可以按照以下步骤进行： 1. 读取输入的图像，将图像转换为 Mediapipe 模型要求的格式（例如 RGB 图像，大小为 256x256 像素）。 2. 初始化 ...
Google MediaPipe holistictrackinggpu.apk Holistic 全面跟踪
03-17
Google MediaPipe holistictrackinggpu.apk Holistic 全面跟踪
MediaPipe学习笔记（一）开发环境搭建（win10+vs2019）
aggs1990的专栏
03-20 2452
因工作需要，再次编译MediaPipe库，上次只是走了下流程，没有任何记录，本次编译时，发现不少问题，所以记录下，供有需要的小伙伴使用。
cpp-MediaPipe是一个用于构建多模式应用机器学习管道的跨平台框架
08-16
MediaPipe是一个用于构建多模式应用机器学习管道的跨平台框架
2020 科大讯飞全球开发者大会节目单来了！
我爱计算机视觉
10-15 756
我爱计算机视觉微信号:aicvmlQQ群:805388940微博知乎:@我爱计算机视觉投稿:amos@52cv.net网站:www.52cv.net在看，让更多人看到 点击官网立即报名...
技术笔记Android应用MediaPipe（一）：Windows安装MediaPipe
userhu2012的博客
11-17 5440
MediaPipe提供跨平台，为实时流媒体提供自定义的机器学习解决方案的应用框架。
Windows下编译Mediapipe,C++版本
Mike
07-06 3366
Windows下编译Mediapipe出现问题及解决
mediapipe学习-手势识别windows(2)
yunteng521的博客
08-07 1168
mediapipe学习-手势识别windows(2)
MediaPipe的安装（Win10，需自备魔法）
warcarlyp的博客
07-06 1726
MediaPipe的安装（Win10，需自备魔法）
MediaPipe 集成人脸识别，人体姿态评估，人手检测模型
人工智能研究所的博客
01-01 1462
画图完成后，我们可以显示图片方便查看，也可以直接使用OpenCV的imwrite 函数进行结果图片的保存，最后只需要close holistic检测模型，这里在检测多人的时候出现了问题，只是检测了单人，我们后期研究。对于姿势模型的精度足够低以至于所得到的手的ROI仍然不够准确的情况，但我们运行附加的轻型手重新裁剪模型，该模型起着的作用，并且仅花费了手模型推断时间的10％左右。这里我们打印了图片检测的结果，并分别画出人脸检测模型数据，人左右手的检测数据，以及人体姿态检测数据。MediaPipe 的核心框架。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值