python摔倒检测，跌倒检测openpose站立行为检测_python pose库

python摔倒检测，跌倒检测openpose站立行为检测

import cv2
import numpy as np
from torch import from_numpy, jit
from modules.keypoints import extract_keypoints, group_keypoints
from modules.pose import Pose
from action_detect.detect import action_detect
import os
from math import ceil, floor
 
 
os.environ["PYTORCH_JIT"] = "0"
 
class ImageReader(object):
    def __init__(self, file_names):
        self.file_names = file_names
        self.max_idx = len(file_names)
 
    def __iter__(self):
        self.idx = 0
        return self
 
    def __next__(self):
        if self.idx == self.max_idx:
            raise StopIteration
        img = cv2.imread(self.file_names[self.idx], cv2.IMREAD_COLOR)
        if img.size == 0:
            raise IOError('Image {} cannot be read'.format(self.file_names[self.idx]))
        self.idx = self.idx + 1
        return img
 
 
class VideoReader(object):
    def __init__(self, file_name,code_name):
        self.file_name = file_name
        self.code_name = str(code_name)
        try:  # OpenCV needs int to read from webcam
            self.file_name = int(file_name)
        except ValueError:
            pass
 
    def __iter__(self):
        self.cap = cv2.VideoCapture(self.file_name)#读入已有视频检测
        #self.cap = cv2.VideoCapture(0)#调用笔记本内置摄像头检测
        if not self.cap.isOpened():
            raise IOError('Video {} cannot be opened'.format(self.file_name))
        return self
 
    def __next__(self):
        was_read, img = self.cap.read()
        if not was_read:
            raise StopIteration
 
        # print(self.cap.get(7),self.cap.get(5))
        cv2.putText(img,self.code_name, (5,35),
                                cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 255))
        return img
 
def normalize(img, img_mean, img_scale):
    img = np.array(img, dtype=np.float32)
    img = (img - img_mean) * img_scale
    return img
 
 
def pad_width(img, stride, pad_value, min_dims):
    h, w, _ = img.shape
    h = min(min_dims[0], h)
    min_dims[0] = ceil(min_dims[0] / float(stride)) * stride
    min_dims[1] = max(min_dims[1], w)
    min_dims[1] = ceil(min_dims[1] / float(stride)) * stride
    pad = []
    pad.append(int(floor((min_dims[0] - h) / 2.0)))
    pad.append(int(floor((min_dims[1] - w) / 2.0)))
    pad.append(int(min_dims[0] - h - pad[0]))
    pad.append(int(min_dims[1] - w - pad[1]))
    padded_img = cv2.copyMakeBorder(img, pad[0], pad[2], pad[1], pad[3],
                                    cv2.BORDER_CONSTANT, value=pad_value)
    return padded_img, pad
 
def infer_fast(net, img, net_input_height_size, stride, upsample_ratio, cpu,
               pad_value=(0, 0, 0), img_mean=(128, 128, 128), img_scale=1/256):
    height, width, _ = img.shape
    scale = net_input_height_size / height
 
    scaled_img = cv2.resize(img, (0, 0), fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC)
    scaled_img = normalize(scaled_img, img_mean, img_scale)
    min_dims = [net_input_height_size, max(scaled_img.shape[1], net_input_height_size)]
    padded_img, pad = pad_width(scaled_img, stride, pad_value, min_dims)
 
    tensor_img = from_numpy(padded_img).permute(2, 0, 1).unsqueeze(0).float()
    if not cpu:
        #tensor_img = tensor_img.cuda()
        pass
 
    stages_output = net(tensor_img)
 
    # print(stages_output)
 
    stage2_heatmaps = stages_output[-2]
    heatmaps = np.transpose(stage2_heatmaps.squeeze().cpu().data.numpy(), (1, 2, 0))
    heatmaps = cv2.resize(heatmaps, (0, 0), fx=upsample_ratio, fy=upsample_ratio, interpolation=cv2.INTER_CUBIC)
 
    stage2_pafs = stages_output[-1]
    pafs = np.transpose(stage2_pafs.squeeze().cpu().data.numpy(), (1, 2, 0))
    pafs = cv2.resize(pafs, (0, 0), fx=upsample_ratio, fy=upsample_ratio, interpolation=cv2.INTER_CUBIC)
 
    return heatmaps, pafs, scale, pad

python基于openpose跌倒检测可生成视频调用摄像头_哔哩哔哩_bilibili

项目下载：

https://download.csdn.net/download/babyai996/87463578

0基础部署该项目视频教程：

python摔倒检测，跌倒检测openpose站立行为检测视频教程-深度学习文档类资源-CSDN下载