mirror of
https://github.com/gosticks/openpose.git
synced 2026-08-12 20:30:20 +00:00
C++ API & examples improved
This commit is contained in:
gineshidalgo99
@@ -0,0 +1,103 @@
|
||||
// ------------------------- OpenPose API Tutorial - Example 1 - Body from image -------------------------
|
||||
// It reads an image, process it, and displays it with the pose keypoints.
|
||||
|
||||
// Command-line user intraface
|
||||
#define OPENPOSE_FLAGS_DISABLE_POSE
|
||||
#include <openpose/flags.hpp>
|
||||
// OpenPose dependencies
|
||||
#include <openpose/headers.hpp>
|
||||
|
||||
// Custom OpenPose flags
|
||||
// Producer
|
||||
DEFINE_string(image_path, "examples/media/COCO_val2014_000000000192.jpg",
|
||||
"Process an image. Read all standard formats (jpg, png, bmp, etc.).");
|
||||
|
||||
// This worker will just read and return all the jpg files in a directory
|
||||
void display(const std::shared_ptr<std::vector<op::Datum>>& datumsPtr)
|
||||
{
|
||||
// User's displaying/saving/other processing here
|
||||
// datum.cvOutputData: rendered frame with pose or heatmaps
|
||||
// datum.poseKeypoints: Array<float> with the estimated pose
|
||||
if (datumsPtr != nullptr && !datumsPtr->empty())
|
||||
{
|
||||
// Display image
|
||||
cv::imshow("User worker GUI", datumsPtr->at(0).cvOutputData);
|
||||
cv::waitKey(0);
|
||||
}
|
||||
else
|
||||
op::log("Nullptr or empty datumsPtr found.", op::Priority::High);
|
||||
}
|
||||
|
||||
void printKeypoints(const std::shared_ptr<std::vector<op::Datum>>& datumsPtr)
|
||||
{
|
||||
// Example: How to use the pose keypoints
|
||||
if (datumsPtr != nullptr && !datumsPtr->empty())
|
||||
{
|
||||
// Alternative 1
|
||||
op::log("Body keypoints: " + datumsPtr->at(0).poseKeypoints.toString());
|
||||
|
||||
// // Alternative 2
|
||||
// op::log(datumsPtr->at(0).poseKeypoints);
|
||||
|
||||
// // Alternative 3
|
||||
// std::cout << datumsPtr->at(0).poseKeypoints << std::endl;
|
||||
|
||||
// // Alternative 4 - Accesing each element of the keypoints
|
||||
// op::log("\nKeypoints:");
|
||||
// const auto& poseKeypoints = datumsPtr->at(0).poseKeypoints;
|
||||
// op::log("Person pose keypoints:");
|
||||
// for (auto person = 0 ; person < poseKeypoints.getSize(0) ; person++)
|
||||
// {
|
||||
// op::log("Person " + std::to_string(person) + " (x, y, score):");
|
||||
// for (auto bodyPart = 0 ; bodyPart < poseKeypoints.getSize(1) ; bodyPart++)
|
||||
// {
|
||||
// std::string valueToPrint;
|
||||
// for (auto xyscore = 0 ; xyscore < poseKeypoints.getSize(2) ; xyscore++)
|
||||
// valueToPrint += std::to_string( poseKeypoints[{person, bodyPart, xyscore}] ) + " ";
|
||||
// op::log(valueToPrint);
|
||||
// }
|
||||
// }
|
||||
// op::log(" ");
|
||||
}
|
||||
else
|
||||
op::log("Nullptr or empty datumsPtr found.", op::Priority::High);
|
||||
}
|
||||
|
||||
int bodyFromImage()
|
||||
{
|
||||
op::log("Starting OpenPose demo...", op::Priority::High);
|
||||
|
||||
// Configuring OpenPose
|
||||
op::log("Configuring OpenPose...", op::Priority::High);
|
||||
op::Wrapper<std::vector<op::Datum>> opWrapper{op::ThreadManagerMode::Asynchronous};
|
||||
// Set to single-thread (for sequential processing and/or debugging and/or reducing latency)
|
||||
if (FLAGS_disable_multi_thread)
|
||||
opWrapper.disableMultiThreading();
|
||||
// Starting OpenPose
|
||||
op::log("Starting thread(s)...", op::Priority::High);
|
||||
opWrapper.start();
|
||||
|
||||
// Process and display image
|
||||
const auto imageToProcess = cv::imread(FLAGS_image_path);
|
||||
auto datumProcessed = opWrapper.emplaceAndPop(imageToProcess);
|
||||
if (datumProcessed != nullptr)
|
||||
{
|
||||
printKeypoints(datumProcessed);
|
||||
display(datumProcessed);
|
||||
}
|
||||
else
|
||||
op::log("Image could not be processed.", op::Priority::High);
|
||||
|
||||
// Return successful message
|
||||
op::log("Stopping OpenPose...", op::Priority::High);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// Parsing command line flags
|
||||
gflags::ParseCommandLineFlags(&argc, &argv, true);
|
||||
|
||||
// Running bodyFromImage
|
||||
return bodyFromImage();
|
||||
}
|
||||
@@ -0,0 +1,85 @@
|
||||
// ------------------------- OpenPose API Tutorial - Example 2 - Whole body from image -------------------------
|
||||
// It reads an image, process it, and displays it with the pose, hand, and face keypoints.
|
||||
|
||||
// Command-line user intraface
|
||||
#define OPENPOSE_FLAGS_DISABLE_POSE
|
||||
#include <openpose/flags.hpp>
|
||||
// OpenPose dependencies
|
||||
#include <openpose/headers.hpp>
|
||||
|
||||
// Custom OpenPose flags
|
||||
// Producer
|
||||
DEFINE_string(image_path, "examples/media/COCO_val2014_000000000241.jpg",
|
||||
"Process an image. Read all standard formats (jpg, png, bmp, etc.).");
|
||||
|
||||
// This worker will just read and return all the jpg files in a directory
|
||||
void display(const std::shared_ptr<std::vector<op::Datum>>& datumsPtr)
|
||||
{
|
||||
// User's displaying/saving/other processing here
|
||||
// datum.cvOutputData: rendered frame with pose or heatmaps
|
||||
// datum.poseKeypoints: Array<float> with the estimated pose
|
||||
if (datumsPtr != nullptr && !datumsPtr->empty())
|
||||
{
|
||||
// Display image
|
||||
cv::imshow("User worker GUI", datumsPtr->at(0).cvOutputData);
|
||||
cv::waitKey(0);
|
||||
}
|
||||
else
|
||||
op::log("Nullptr or empty datumsPtr found.", op::Priority::High);
|
||||
}
|
||||
|
||||
void printKeypoints(const std::shared_ptr<std::vector<op::Datum>>& datumsPtr)
|
||||
{
|
||||
// Example: How to use the pose keypoints
|
||||
if (datumsPtr != nullptr && !datumsPtr->empty())
|
||||
{
|
||||
op::log("Body keypoints: " + datumsPtr->at(0).poseKeypoints.toString());
|
||||
op::log("Face keypoints: " + datumsPtr->at(0).faceKeypoints.toString());
|
||||
op::log("Left hand keypoints: " + datumsPtr->at(0).handKeypoints[0].toString());
|
||||
op::log("Right hand keypoints: " + datumsPtr->at(0).handKeypoints[1].toString());
|
||||
}
|
||||
else
|
||||
op::log("Nullptr or empty datumsPtr found.", op::Priority::High);
|
||||
}
|
||||
|
||||
int wholeBodyFromImage()
|
||||
{
|
||||
op::log("Starting OpenPose demo...", op::Priority::High);
|
||||
|
||||
// Configuring OpenPose
|
||||
op::log("Configuring OpenPose...", op::Priority::High);
|
||||
op::Wrapper<std::vector<op::Datum>> opWrapper{op::ThreadManagerMode::Asynchronous};
|
||||
// Add hand and face
|
||||
opWrapper.configure(op::WrapperStructFace{true});
|
||||
opWrapper.configure(op::WrapperStructHand{true});
|
||||
// Set to single-thread (for sequential processing and/or debugging and/or reducing latency)
|
||||
if (FLAGS_disable_multi_thread)
|
||||
opWrapper.disableMultiThreading();
|
||||
// Starting OpenPose
|
||||
op::log("Starting thread(s)...", op::Priority::High);
|
||||
opWrapper.start();
|
||||
|
||||
// Process and display image
|
||||
const auto imageToProcess = cv::imread(FLAGS_image_path);
|
||||
auto datumProcessed = opWrapper.emplaceAndPop(imageToProcess);
|
||||
if (datumProcessed != nullptr)
|
||||
{
|
||||
printKeypoints(datumProcessed);
|
||||
display(datumProcessed);
|
||||
}
|
||||
else
|
||||
op::log("Image could not be processed.", op::Priority::High);
|
||||
|
||||
// Return successful message
|
||||
op::log("Stopping OpenPose...", op::Priority::High);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// Parsing command line flags
|
||||
gflags::ParseCommandLineFlags(&argc, &argv, true);
|
||||
|
||||
// Running wholeBodyFromImage
|
||||
return wholeBodyFromImage();
|
||||
}
|
||||
@@ -0,0 +1,150 @@
|
||||
// ------------------------- OpenPose API Tutorial - Example 3 - Body from image configurable -------------------------
|
||||
// It reads an image, process it, and displays it with the pose (and optionally hand and face) keypoints. In addition,
|
||||
// it includes all the OpenPose configuration flags (enable/disable hand, face, output saving, etc.).
|
||||
|
||||
// Command-line user intraface
|
||||
#define OPENPOSE_FLAGS_DISABLE_PRODUCER
|
||||
#define OPENPOSE_FLAGS_DISABLE_DISPLAY
|
||||
#include <openpose/flags.hpp>
|
||||
// OpenPose dependencies
|
||||
#include <openpose/headers.hpp>
|
||||
|
||||
// Custom OpenPose flags
|
||||
// Producer
|
||||
DEFINE_string(image_path, "examples/media/COCO_val2014_000000000294.jpg",
|
||||
"Process an image. Read all standard formats (jpg, png, bmp, etc.).");
|
||||
|
||||
// This worker will just read and return all the jpg files in a directory
|
||||
void display(const std::shared_ptr<std::vector<op::Datum>>& datumsPtr)
|
||||
{
|
||||
// User's displaying/saving/other processing here
|
||||
// datum.cvOutputData: rendered frame with pose or heatmaps
|
||||
// datum.poseKeypoints: Array<float> with the estimated pose
|
||||
if (datumsPtr != nullptr && !datumsPtr->empty())
|
||||
{
|
||||
// Display image
|
||||
cv::imshow("User worker GUI", datumsPtr->at(0).cvOutputData);
|
||||
cv::waitKey(0);
|
||||
}
|
||||
else
|
||||
op::log("Nullptr or empty datumsPtr found.", op::Priority::High);
|
||||
}
|
||||
|
||||
void printKeypoints(const std::shared_ptr<std::vector<op::Datum>>& datumsPtr)
|
||||
{
|
||||
// Example: How to use the pose keypoints
|
||||
if (datumsPtr != nullptr && !datumsPtr->empty())
|
||||
{
|
||||
op::log("Body keypoints: " + datumsPtr->at(0).poseKeypoints.toString());
|
||||
op::log("Face keypoints: " + datumsPtr->at(0).faceKeypoints.toString());
|
||||
op::log("Left hand keypoints: " + datumsPtr->at(0).handKeypoints[0].toString());
|
||||
op::log("Right hand keypoints: " + datumsPtr->at(0).handKeypoints[1].toString());
|
||||
}
|
||||
else
|
||||
op::log("Nullptr or empty datumsPtr found.", op::Priority::High);
|
||||
}
|
||||
|
||||
int wholeBodyFromImage()
|
||||
{
|
||||
op::log("Starting OpenPose demo...", op::Priority::High);
|
||||
|
||||
// logging_level
|
||||
op::check(0 <= FLAGS_logging_level && FLAGS_logging_level <= 255, "Wrong logging_level value.",
|
||||
__LINE__, __FUNCTION__, __FILE__);
|
||||
op::ConfigureLog::setPriorityThreshold((op::Priority)FLAGS_logging_level);
|
||||
op::Profiler::setDefaultX(FLAGS_profile_speed);
|
||||
|
||||
// Applying user defined configuration - GFlags to program variables
|
||||
// outputSize
|
||||
const auto outputSize = op::flagsToPoint(FLAGS_output_resolution, "-1x-1");
|
||||
// netInputSize
|
||||
const auto netInputSize = op::flagsToPoint(FLAGS_net_resolution, "-1x368");
|
||||
// faceNetInputSize
|
||||
const auto faceNetInputSize = op::flagsToPoint(FLAGS_face_net_resolution, "368x368 (multiples of 16)");
|
||||
// handNetInputSize
|
||||
const auto handNetInputSize = op::flagsToPoint(FLAGS_hand_net_resolution, "368x368 (multiples of 16)");
|
||||
// poseModel
|
||||
const auto poseModel = op::flagsToPoseModel(FLAGS_model_pose);
|
||||
// JSON saving
|
||||
if (!FLAGS_write_keypoint.empty())
|
||||
op::log("Flag `write_keypoint` is deprecated and will eventually be removed."
|
||||
" Please, use `write_json` instead.", op::Priority::Max);
|
||||
// keypointScale
|
||||
const auto keypointScale = op::flagsToScaleMode(FLAGS_keypoint_scale);
|
||||
// heatmaps to add
|
||||
const auto heatMapTypes = op::flagsToHeatMaps(FLAGS_heatmaps_add_parts, FLAGS_heatmaps_add_bkg,
|
||||
FLAGS_heatmaps_add_PAFs);
|
||||
const auto heatMapScale = op::flagsToHeatMapScaleMode(FLAGS_heatmaps_scale);
|
||||
// >1 camera view?
|
||||
const auto multipleView = (FLAGS_3d || FLAGS_3d_views > 1);
|
||||
// Enabling Google Logging
|
||||
const bool enableGoogleLogging = true;
|
||||
// Logging
|
||||
op::log("", op::Priority::Low, __LINE__, __FUNCTION__, __FILE__);
|
||||
|
||||
// Configuring OpenPose
|
||||
op::log("Configuring OpenPose...", op::Priority::High);
|
||||
op::Wrapper<std::vector<op::Datum>> opWrapper{op::ThreadManagerMode::Asynchronous};
|
||||
// Pose configuration (use WrapperStructPose{} for default and recommended configuration)
|
||||
const op::WrapperStructPose wrapperStructPose{
|
||||
!FLAGS_body_disable, netInputSize, outputSize, keypointScale, FLAGS_num_gpu, FLAGS_num_gpu_start,
|
||||
FLAGS_scale_number, (float)FLAGS_scale_gap, op::flagsToRenderMode(FLAGS_render_pose, multipleView),
|
||||
poseModel, !FLAGS_disable_blending, (float)FLAGS_alpha_pose, (float)FLAGS_alpha_heatmap,
|
||||
FLAGS_part_to_show, FLAGS_model_folder, heatMapTypes, heatMapScale, FLAGS_part_candidates,
|
||||
(float)FLAGS_render_threshold, FLAGS_number_people_max, enableGoogleLogging};
|
||||
// Face configuration (use op::WrapperStructFace{} to disable it)
|
||||
const op::WrapperStructFace wrapperStructFace{
|
||||
FLAGS_face, faceNetInputSize, op::flagsToRenderMode(FLAGS_face_render, multipleView, FLAGS_render_pose),
|
||||
(float)FLAGS_face_alpha_pose, (float)FLAGS_face_alpha_heatmap, (float)FLAGS_face_render_threshold};
|
||||
// Hand configuration (use op::WrapperStructHand{} to disable it)
|
||||
const op::WrapperStructHand wrapperStructHand{
|
||||
FLAGS_hand, handNetInputSize, FLAGS_hand_scale_number, (float)FLAGS_hand_scale_range, FLAGS_hand_tracking,
|
||||
op::flagsToRenderMode(FLAGS_hand_render, multipleView, FLAGS_render_pose), (float)FLAGS_hand_alpha_pose,
|
||||
(float)FLAGS_hand_alpha_heatmap, (float)FLAGS_hand_render_threshold};
|
||||
// Extra functionality configuration (use op::WrapperStructExtra{} to disable it)
|
||||
const op::WrapperStructExtra wrapperStructExtra{
|
||||
FLAGS_3d, FLAGS_3d_min_views, FLAGS_identification, FLAGS_tracking, FLAGS_ik_threads};
|
||||
// Consumer (comment or use default argument to disable any output)
|
||||
const auto displayMode = op::DisplayMode::NoDisplay;
|
||||
const bool guiVerbose = false;
|
||||
const bool fullScreen = false;
|
||||
const op::WrapperStructOutput wrapperStructOutput{
|
||||
displayMode, guiVerbose, fullScreen, FLAGS_write_keypoint,
|
||||
op::stringToDataFormat(FLAGS_write_keypoint_format), FLAGS_write_json, FLAGS_write_coco_json,
|
||||
FLAGS_write_coco_foot_json, FLAGS_write_images, FLAGS_write_images_format, FLAGS_write_video,
|
||||
FLAGS_camera_fps, FLAGS_write_heatmaps, FLAGS_write_heatmaps_format, FLAGS_write_video_adam,
|
||||
FLAGS_write_bvh, FLAGS_udp_host, FLAGS_udp_port};
|
||||
// Configure wrapper
|
||||
opWrapper.configure(wrapperStructPose, wrapperStructFace, wrapperStructHand, wrapperStructExtra,
|
||||
op::WrapperStructInput{}, wrapperStructOutput);
|
||||
// Set to single-thread (for sequential processing and/or debugging and/or reducing latency)
|
||||
if (FLAGS_disable_multi_thread)
|
||||
opWrapper.disableMultiThreading();
|
||||
// Starting OpenPose
|
||||
op::log("Starting thread(s)...", op::Priority::High);
|
||||
opWrapper.start();
|
||||
|
||||
// Process and display image
|
||||
const auto imageToProcess = cv::imread(FLAGS_image_path);
|
||||
auto datumProcessed = opWrapper.emplaceAndPop(imageToProcess);
|
||||
if (datumProcessed != nullptr)
|
||||
{
|
||||
printKeypoints(datumProcessed);
|
||||
display(datumProcessed);
|
||||
}
|
||||
else
|
||||
op::log("Image could not be processed.", op::Priority::High);
|
||||
|
||||
// Return successful message
|
||||
op::log("Stopping OpenPose...", op::Priority::High);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// Parsing command line flags
|
||||
gflags::ParseCommandLineFlags(&argc, &argv, true);
|
||||
|
||||
// Running wholeBodyFromImage
|
||||
return wholeBodyFromImage();
|
||||
}
|
||||
@@ -0,0 +1,314 @@
|
||||
// ------------------------- OpenPose Library Tutorial - Wrapper - Example 1 - Asynchronous -------------------------
|
||||
// Asynchronous mode: ideal for fast prototyping when performance is not an issue. The user emplaces/pushes and pops frames from the OpenPose wrapper
|
||||
// when he desires to.
|
||||
|
||||
// This example shows the user how to use the OpenPose wrapper class:
|
||||
// 1. User reads images
|
||||
// 2. Extract and render keypoint / heatmap / PAF of that image
|
||||
// 3. Save the results on disk
|
||||
// 4. User displays the rendered pose
|
||||
// Everything in a multi-thread scenario
|
||||
// In addition to the previous OpenPose modules, we also need to use:
|
||||
// 1. `core` module:
|
||||
// For the Array<float> class that the `pose` module needs
|
||||
// For the Datum struct that the `thread` module sends between the queues
|
||||
// 2. `utilities` module: for the error & logging functions, i.e. op::error & op::log respectively
|
||||
// This file should only be used for the user to take specific examples.
|
||||
|
||||
// Command-line user intraface
|
||||
#define OPENPOSE_FLAGS_DISABLE_PRODUCER
|
||||
#define OPENPOSE_FLAGS_DISABLE_DISPLAY
|
||||
#include <openpose/flags.hpp>
|
||||
// OpenPose dependencies
|
||||
#include <openpose/headers.hpp>
|
||||
|
||||
// Custom OpenPose flags
|
||||
// Producer
|
||||
DEFINE_string(image_dir, "examples/media/",
|
||||
"Process a directory of images. Read all standard formats (jpg, png, bmp, etc.).");
|
||||
|
||||
// If the user needs his own variables, he can inherit the op::Datum struct and add them
|
||||
// UserDatum can be directly used by the OpenPose wrapper because it inherits from op::Datum, just define Wrapper<UserDatum> instead of
|
||||
// Wrapper<op::Datum>
|
||||
struct UserDatum : public op::Datum
|
||||
{
|
||||
bool boolThatUserNeedsForSomeReason;
|
||||
|
||||
UserDatum(const bool boolThatUserNeedsForSomeReason_ = false) :
|
||||
boolThatUserNeedsForSomeReason{boolThatUserNeedsForSomeReason_}
|
||||
{}
|
||||
};
|
||||
|
||||
// The W-classes can be implemented either as a template or as simple classes given
|
||||
// that the user usually knows which kind of data he will move between the queues,
|
||||
// in this case we assume a std::shared_ptr of a std::vector of UserDatum
|
||||
|
||||
// This worker will just read and return all the jpg files in a directory
|
||||
class UserInputClass
|
||||
{
|
||||
public:
|
||||
UserInputClass(const std::string& directoryPath) :
|
||||
mImageFiles{op::getFilesOnDirectory(directoryPath, "jpg")},
|
||||
// If we want "jpg" + "png" images
|
||||
// mImageFiles{op::getFilesOnDirectory(directoryPath, std::vector<std::string>{"jpg", "png"})},
|
||||
mCounter{0},
|
||||
mClosed{false}
|
||||
{
|
||||
if (mImageFiles.empty())
|
||||
op::error("No images found on: " + directoryPath, __LINE__, __FUNCTION__, __FILE__);
|
||||
}
|
||||
|
||||
std::shared_ptr<std::vector<UserDatum>> createDatum()
|
||||
{
|
||||
// Close program when empty frame
|
||||
if (mClosed || mImageFiles.size() <= mCounter)
|
||||
{
|
||||
op::log("Last frame read and added to queue. Closing program after it is processed.", op::Priority::High);
|
||||
// This funtion stops this worker, which will eventually stop the whole thread system once all the frames
|
||||
// have been processed
|
||||
mClosed = true;
|
||||
return nullptr;
|
||||
}
|
||||
else // if (!mClosed)
|
||||
{
|
||||
// Create new datum
|
||||
auto datumsPtr = std::make_shared<std::vector<UserDatum>>();
|
||||
datumsPtr->emplace_back();
|
||||
auto& datum = datumsPtr->at(0);
|
||||
|
||||
// Fill datum
|
||||
datum.cvInputData = cv::imread(mImageFiles.at(mCounter++));
|
||||
|
||||
// If empty frame -> return nullptr
|
||||
if (datum.cvInputData.empty())
|
||||
{
|
||||
op::log("Empty frame detected on path: " + mImageFiles.at(mCounter-1) + ". Closing program.",
|
||||
op::Priority::High);
|
||||
mClosed = true;
|
||||
datumsPtr = nullptr;
|
||||
}
|
||||
|
||||
return datumsPtr;
|
||||
}
|
||||
}
|
||||
|
||||
bool isFinished() const
|
||||
{
|
||||
return mClosed;
|
||||
}
|
||||
|
||||
private:
|
||||
const std::vector<std::string> mImageFiles;
|
||||
unsigned long long mCounter;
|
||||
bool mClosed;
|
||||
};
|
||||
|
||||
// This worker will just read and return all the jpg files in a directory
|
||||
class UserOutputClass
|
||||
{
|
||||
public:
|
||||
bool display(const std::shared_ptr<std::vector<UserDatum>>& datumsPtr)
|
||||
{
|
||||
// User's displaying/saving/other processing here
|
||||
// datum.cvOutputData: rendered frame with pose or heatmaps
|
||||
// datum.poseKeypoints: Array<float> with the estimated pose
|
||||
char key = ' ';
|
||||
if (datumsPtr != nullptr && !datumsPtr->empty())
|
||||
{
|
||||
cv::imshow("User worker GUI", datumsPtr->at(0).cvOutputData);
|
||||
// Display image and sleeps at least 1 ms (it usually sleeps ~5-10 msec to display the image)
|
||||
key = (char)cv::waitKey(1);
|
||||
}
|
||||
else
|
||||
op::log("Nullptr or empty datumsPtr found.", op::Priority::High, __LINE__, __FUNCTION__, __FILE__);
|
||||
return (key == 27);
|
||||
}
|
||||
void printKeypoints(const std::shared_ptr<std::vector<UserDatum>>& datumsPtr)
|
||||
{
|
||||
// Example: How to use the pose keypoints
|
||||
if (datumsPtr != nullptr && !datumsPtr->empty())
|
||||
{
|
||||
op::log("\nKeypoints:");
|
||||
// Accesing each element of the keypoints
|
||||
const auto& poseKeypoints = datumsPtr->at(0).poseKeypoints;
|
||||
op::log("Person pose keypoints:");
|
||||
for (auto person = 0 ; person < poseKeypoints.getSize(0) ; person++)
|
||||
{
|
||||
op::log("Person " + std::to_string(person) + " (x, y, score):");
|
||||
for (auto bodyPart = 0 ; bodyPart < poseKeypoints.getSize(1) ; bodyPart++)
|
||||
{
|
||||
std::string valueToPrint;
|
||||
for (auto xyscore = 0 ; xyscore < poseKeypoints.getSize(2) ; xyscore++)
|
||||
valueToPrint += std::to_string( poseKeypoints[{person, bodyPart, xyscore}] ) + " ";
|
||||
op::log(valueToPrint);
|
||||
}
|
||||
}
|
||||
op::log(" ");
|
||||
// Alternative: just getting std::string equivalent
|
||||
op::log("Face keypoints: " + datumsPtr->at(0).faceKeypoints.toString());
|
||||
op::log("Left hand keypoints: " + datumsPtr->at(0).handKeypoints[0].toString());
|
||||
op::log("Right hand keypoints: " + datumsPtr->at(0).handKeypoints[1].toString());
|
||||
// Heatmaps
|
||||
const auto& poseHeatMaps = datumsPtr->at(0).poseHeatMaps;
|
||||
if (!poseHeatMaps.empty())
|
||||
{
|
||||
op::log("Pose heatmaps size: [" + std::to_string(poseHeatMaps.getSize(0)) + ", "
|
||||
+ std::to_string(poseHeatMaps.getSize(1)) + ", "
|
||||
+ std::to_string(poseHeatMaps.getSize(2)) + "]");
|
||||
const auto& faceHeatMaps = datumsPtr->at(0).faceHeatMaps;
|
||||
op::log("Face heatmaps size: [" + std::to_string(faceHeatMaps.getSize(0)) + ", "
|
||||
+ std::to_string(faceHeatMaps.getSize(1)) + ", "
|
||||
+ std::to_string(faceHeatMaps.getSize(2)) + ", "
|
||||
+ std::to_string(faceHeatMaps.getSize(3)) + "]");
|
||||
const auto& handHeatMaps = datumsPtr->at(0).handHeatMaps;
|
||||
op::log("Left hand heatmaps size: [" + std::to_string(handHeatMaps[0].getSize(0)) + ", "
|
||||
+ std::to_string(handHeatMaps[0].getSize(1)) + ", "
|
||||
+ std::to_string(handHeatMaps[0].getSize(2)) + ", "
|
||||
+ std::to_string(handHeatMaps[0].getSize(3)) + "]");
|
||||
op::log("Right hand heatmaps size: [" + std::to_string(handHeatMaps[1].getSize(0)) + ", "
|
||||
+ std::to_string(handHeatMaps[1].getSize(1)) + ", "
|
||||
+ std::to_string(handHeatMaps[1].getSize(2)) + ", "
|
||||
+ std::to_string(handHeatMaps[1].getSize(3)) + "]");
|
||||
}
|
||||
}
|
||||
else
|
||||
op::log("Nullptr or empty datumsPtr found.", op::Priority::High, __LINE__, __FUNCTION__, __FILE__);
|
||||
}
|
||||
};
|
||||
|
||||
int openPoseTutorialWrapper3()
|
||||
{
|
||||
try
|
||||
{
|
||||
op::log("Starting OpenPose demo...", op::Priority::High);
|
||||
const auto timerBegin = std::chrono::high_resolution_clock::now();
|
||||
|
||||
// logging_level
|
||||
op::check(0 <= FLAGS_logging_level && FLAGS_logging_level <= 255, "Wrong logging_level value.",
|
||||
__LINE__, __FUNCTION__, __FILE__);
|
||||
op::ConfigureLog::setPriorityThreshold((op::Priority)FLAGS_logging_level);
|
||||
op::Profiler::setDefaultX(FLAGS_profile_speed);
|
||||
|
||||
// Applying user defined configuration - GFlags to program variables
|
||||
// outputSize
|
||||
const auto outputSize = op::flagsToPoint(FLAGS_output_resolution, "-1x-1");
|
||||
// netInputSize
|
||||
const auto netInputSize = op::flagsToPoint(FLAGS_net_resolution, "-1x368");
|
||||
// faceNetInputSize
|
||||
const auto faceNetInputSize = op::flagsToPoint(FLAGS_face_net_resolution, "368x368 (multiples of 16)");
|
||||
// handNetInputSize
|
||||
const auto handNetInputSize = op::flagsToPoint(FLAGS_hand_net_resolution, "368x368 (multiples of 16)");
|
||||
// poseModel
|
||||
const auto poseModel = op::flagsToPoseModel(FLAGS_model_pose);
|
||||
// JSON saving
|
||||
if (!FLAGS_write_keypoint.empty())
|
||||
op::log("Flag `write_keypoint` is deprecated and will eventually be removed."
|
||||
" Please, use `write_json` instead.", op::Priority::Max);
|
||||
// keypointScale
|
||||
const auto keypointScale = op::flagsToScaleMode(FLAGS_keypoint_scale);
|
||||
// heatmaps to add
|
||||
const auto heatMapTypes = op::flagsToHeatMaps(FLAGS_heatmaps_add_parts, FLAGS_heatmaps_add_bkg,
|
||||
FLAGS_heatmaps_add_PAFs);
|
||||
const auto heatMapScale = op::flagsToHeatMapScaleMode(FLAGS_heatmaps_scale);
|
||||
// >1 camera view?
|
||||
const auto multipleView = (FLAGS_3d || FLAGS_3d_views > 1);
|
||||
// Enabling Google Logging
|
||||
const bool enableGoogleLogging = true;
|
||||
// Logging
|
||||
op::log("", op::Priority::Low, __LINE__, __FUNCTION__, __FILE__);
|
||||
|
||||
// Configure OpenPose
|
||||
op::log("Configuring OpenPose wrapper...", op::Priority::Low, __LINE__, __FUNCTION__, __FILE__);
|
||||
op::Wrapper<std::vector<UserDatum>> opWrapper{op::ThreadManagerMode::Asynchronous};
|
||||
// Pose configuration (use WrapperStructPose{} for default and recommended configuration)
|
||||
const op::WrapperStructPose wrapperStructPose{
|
||||
!FLAGS_body_disable, netInputSize, outputSize, keypointScale, FLAGS_num_gpu, FLAGS_num_gpu_start,
|
||||
FLAGS_scale_number, (float)FLAGS_scale_gap, op::flagsToRenderMode(FLAGS_render_pose, multipleView),
|
||||
poseModel, !FLAGS_disable_blending, (float)FLAGS_alpha_pose, (float)FLAGS_alpha_heatmap,
|
||||
FLAGS_part_to_show, FLAGS_model_folder, heatMapTypes, heatMapScale, FLAGS_part_candidates,
|
||||
(float)FLAGS_render_threshold, FLAGS_number_people_max, enableGoogleLogging};
|
||||
// Face configuration (use op::WrapperStructFace{} to disable it)
|
||||
const op::WrapperStructFace wrapperStructFace{
|
||||
FLAGS_face, faceNetInputSize, op::flagsToRenderMode(FLAGS_face_render, multipleView, FLAGS_render_pose),
|
||||
(float)FLAGS_face_alpha_pose, (float)FLAGS_face_alpha_heatmap, (float)FLAGS_face_render_threshold};
|
||||
// Hand configuration (use op::WrapperStructHand{} to disable it)
|
||||
const op::WrapperStructHand wrapperStructHand{
|
||||
FLAGS_hand, handNetInputSize, FLAGS_hand_scale_number, (float)FLAGS_hand_scale_range, FLAGS_hand_tracking,
|
||||
op::flagsToRenderMode(FLAGS_hand_render, multipleView, FLAGS_render_pose), (float)FLAGS_hand_alpha_pose,
|
||||
(float)FLAGS_hand_alpha_heatmap, (float)FLAGS_hand_render_threshold};
|
||||
// Extra functionality configuration (use op::WrapperStructExtra{} to disable it)
|
||||
const op::WrapperStructExtra wrapperStructExtra{
|
||||
FLAGS_3d, FLAGS_3d_min_views, FLAGS_identification, FLAGS_tracking, FLAGS_ik_threads};
|
||||
// Consumer (comment or use default argument to disable any output)
|
||||
const auto displayMode = op::DisplayMode::NoDisplay;
|
||||
const bool guiVerbose = false;
|
||||
const bool fullScreen = false;
|
||||
const op::WrapperStructOutput wrapperStructOutput{
|
||||
displayMode, guiVerbose, fullScreen, FLAGS_write_keypoint,
|
||||
op::stringToDataFormat(FLAGS_write_keypoint_format), FLAGS_write_json, FLAGS_write_coco_json,
|
||||
FLAGS_write_coco_foot_json, FLAGS_write_images, FLAGS_write_images_format, FLAGS_write_video,
|
||||
FLAGS_camera_fps, FLAGS_write_heatmaps, FLAGS_write_heatmaps_format, FLAGS_write_video_adam,
|
||||
FLAGS_write_bvh, FLAGS_udp_host, FLAGS_udp_port};
|
||||
// Configure wrapper
|
||||
opWrapper.configure(wrapperStructPose, wrapperStructFace, wrapperStructHand, wrapperStructExtra,
|
||||
op::WrapperStructInput{}, wrapperStructOutput);
|
||||
// Set to single-thread (for sequential processing and/or debugging and/or reducing latency)
|
||||
if (FLAGS_disable_multi_thread)
|
||||
opWrapper.disableMultiThreading();
|
||||
|
||||
op::log("Starting thread(s)...", op::Priority::High);
|
||||
opWrapper.start();
|
||||
|
||||
// User processing
|
||||
UserInputClass userInputClass(FLAGS_image_dir);
|
||||
UserOutputClass userOutputClass;
|
||||
bool userWantsToExit = false;
|
||||
while (!userWantsToExit && !userInputClass.isFinished())
|
||||
{
|
||||
// Push frame
|
||||
auto datumToProcess = userInputClass.createDatum();
|
||||
if (datumToProcess != nullptr)
|
||||
{
|
||||
auto successfullyEmplaced = opWrapper.waitAndEmplace(datumToProcess);
|
||||
// Pop frame
|
||||
std::shared_ptr<std::vector<UserDatum>> datumProcessed;
|
||||
if (successfullyEmplaced && opWrapper.waitAndPop(datumProcessed))
|
||||
{
|
||||
userWantsToExit = userOutputClass.display(datumProcessed);
|
||||
userOutputClass.printKeypoints(datumProcessed);
|
||||
}
|
||||
else
|
||||
op::log("Processed datum could not be emplaced.", op::Priority::High,
|
||||
__LINE__, __FUNCTION__, __FILE__);
|
||||
}
|
||||
}
|
||||
|
||||
op::log("Stopping thread(s)", op::Priority::High);
|
||||
opWrapper.stop();
|
||||
|
||||
// Measuring total time
|
||||
const auto now = std::chrono::high_resolution_clock::now();
|
||||
const auto totalTimeSec = (double)std::chrono::duration_cast<std::chrono::nanoseconds>(now-timerBegin).count()
|
||||
* 1e-9;
|
||||
const auto message = "OpenPose demo successfully finished. Total time: "
|
||||
+ std::to_string(totalTimeSec) + " seconds.";
|
||||
op::log(message, op::Priority::High);
|
||||
|
||||
// Return successful message
|
||||
return 0;
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
op::error(e.what(), __LINE__, __FUNCTION__, __FILE__);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// Parsing command line flags
|
||||
gflags::ParseCommandLineFlags(&argc, &argv, true);
|
||||
|
||||
// Running openPoseTutorialWrapper3
|
||||
return openPoseTutorialWrapper3();
|
||||
}
|
||||
@@ -0,0 +1,251 @@
|
||||
// ------------------------- OpenPose Library Tutorial - Wrapper - Example 3 - Asynchronous Output -------------------------
|
||||
// Asynchronous output mode: ideal for fast prototyping when performance is not an issue and user wants to use the output OpenPose format. The user
|
||||
// simply gets the processed frames from the OpenPose wrapper when he desires to.
|
||||
|
||||
// This example shows the user how to use the OpenPose wrapper class:
|
||||
// 1. Read folder of images / video / webcam
|
||||
// 2. Extract and render keypoint / heatmap / PAF of that image
|
||||
// 3. Save the results on disk
|
||||
// 4. User displays the rendered pose
|
||||
// Everything in a multi-thread scenario
|
||||
// In addition to the previous OpenPose modules, we also need to use:
|
||||
// 1. `core` module:
|
||||
// For the Array<float> class that the `pose` module needs
|
||||
// For the Datum struct that the `thread` module sends between the queues
|
||||
// 2. `utilities` module: for the error & logging functions, i.e. op::error & op::log respectively
|
||||
// This file should only be used for the user to take specific examples.
|
||||
|
||||
// Command-line user intraface
|
||||
#define OPENPOSE_FLAGS_DISABLE_DISPLAY
|
||||
#include <openpose/flags.hpp>
|
||||
// OpenPose dependencies
|
||||
#include <openpose/headers.hpp>
|
||||
|
||||
// If the user needs his own variables, he can inherit the op::Datum struct and add them
|
||||
// UserDatum can be directly used by the OpenPose wrapper because it inherits from op::Datum, just define
|
||||
// Wrapper<UserDatum> instead of Wrapper<op::Datum>
|
||||
struct UserDatum : public op::Datum
|
||||
{
|
||||
bool boolThatUserNeedsForSomeReason;
|
||||
|
||||
UserDatum(const bool boolThatUserNeedsForSomeReason_ = false) :
|
||||
boolThatUserNeedsForSomeReason{boolThatUserNeedsForSomeReason_}
|
||||
{}
|
||||
};
|
||||
|
||||
// The W-classes can be implemented either as a template or as simple classes given
|
||||
// that the user usually knows which kind of data he will move between the queues,
|
||||
// in this case we assume a std::shared_ptr of a std::vector of UserDatum
|
||||
|
||||
// This worker will just read and return all the jpg files in a directory
|
||||
class UserOutputClass
|
||||
{
|
||||
public:
|
||||
bool display(const std::shared_ptr<std::vector<UserDatum>>& datumsPtr)
|
||||
{
|
||||
// User's displaying/saving/other processing here
|
||||
// datum.cvOutputData: rendered frame with pose or heatmaps
|
||||
// datum.poseKeypoints: Array<float> with the estimated pose
|
||||
char key = ' ';
|
||||
if (datumsPtr != nullptr && !datumsPtr->empty())
|
||||
{
|
||||
cv::imshow("User worker GUI", datumsPtr->at(0).cvOutputData);
|
||||
// Display image and sleeps at least 1 ms (it usually sleeps ~5-10 msec to display the image)
|
||||
key = (char)cv::waitKey(1);
|
||||
}
|
||||
else
|
||||
op::log("Nullptr or empty datumsPtr found.", op::Priority::High, __LINE__, __FUNCTION__, __FILE__);
|
||||
return (key == 27);
|
||||
}
|
||||
void printKeypoints(const std::shared_ptr<std::vector<UserDatum>>& datumsPtr)
|
||||
{
|
||||
// Example: How to use the pose keypoints
|
||||
if (datumsPtr != nullptr && !datumsPtr->empty())
|
||||
{
|
||||
op::log("\nKeypoints:");
|
||||
// Accesing each element of the keypoints
|
||||
const auto& poseKeypoints = datumsPtr->at(0).poseKeypoints;
|
||||
op::log("Person pose keypoints:");
|
||||
for (auto person = 0 ; person < poseKeypoints.getSize(0) ; person++)
|
||||
{
|
||||
op::log("Person " + std::to_string(person) + " (x, y, score):");
|
||||
for (auto bodyPart = 0 ; bodyPart < poseKeypoints.getSize(1) ; bodyPart++)
|
||||
{
|
||||
std::string valueToPrint;
|
||||
for (auto xyscore = 0 ; xyscore < poseKeypoints.getSize(2) ; xyscore++)
|
||||
{
|
||||
valueToPrint += std::to_string( poseKeypoints[{person, bodyPart, xyscore}] ) + " ";
|
||||
}
|
||||
op::log(valueToPrint);
|
||||
}
|
||||
}
|
||||
op::log(" ");
|
||||
// Alternative: just getting std::string equivalent
|
||||
op::log("Face keypoints: " + datumsPtr->at(0).faceKeypoints.toString());
|
||||
op::log("Left hand keypoints: " + datumsPtr->at(0).handKeypoints[0].toString());
|
||||
op::log("Right hand keypoints: " + datumsPtr->at(0).handKeypoints[1].toString());
|
||||
// Heatmaps
|
||||
const auto& poseHeatMaps = datumsPtr->at(0).poseHeatMaps;
|
||||
if (!poseHeatMaps.empty())
|
||||
{
|
||||
op::log("Pose heatmaps size: [" + std::to_string(poseHeatMaps.getSize(0)) + ", "
|
||||
+ std::to_string(poseHeatMaps.getSize(1)) + ", "
|
||||
+ std::to_string(poseHeatMaps.getSize(2)) + "]");
|
||||
const auto& faceHeatMaps = datumsPtr->at(0).faceHeatMaps;
|
||||
op::log("Face heatmaps size: [" + std::to_string(faceHeatMaps.getSize(0)) + ", "
|
||||
+ std::to_string(faceHeatMaps.getSize(1)) + ", "
|
||||
+ std::to_string(faceHeatMaps.getSize(2)) + ", "
|
||||
+ std::to_string(faceHeatMaps.getSize(3)) + "]");
|
||||
const auto& handHeatMaps = datumsPtr->at(0).handHeatMaps;
|
||||
op::log("Left hand heatmaps size: [" + std::to_string(handHeatMaps[0].getSize(0)) + ", "
|
||||
+ std::to_string(handHeatMaps[0].getSize(1)) + ", "
|
||||
+ std::to_string(handHeatMaps[0].getSize(2)) + ", "
|
||||
+ std::to_string(handHeatMaps[0].getSize(3)) + "]");
|
||||
op::log("Right hand heatmaps size: [" + std::to_string(handHeatMaps[1].getSize(0)) + ", "
|
||||
+ std::to_string(handHeatMaps[1].getSize(1)) + ", "
|
||||
+ std::to_string(handHeatMaps[1].getSize(2)) + ", "
|
||||
+ std::to_string(handHeatMaps[1].getSize(3)) + "]");
|
||||
}
|
||||
}
|
||||
else
|
||||
op::log("Nullptr or empty datumsPtr found.", op::Priority::High, __LINE__, __FUNCTION__, __FILE__);
|
||||
}
|
||||
};
|
||||
|
||||
int openPoseTutorialWrapper1()
|
||||
{
|
||||
try
|
||||
{
|
||||
op::log("Starting OpenPose demo...", op::Priority::High);
|
||||
const auto timerBegin = std::chrono::high_resolution_clock::now();
|
||||
|
||||
// logging_level
|
||||
op::check(0 <= FLAGS_logging_level && FLAGS_logging_level <= 255, "Wrong logging_level value.",
|
||||
__LINE__, __FUNCTION__, __FILE__);
|
||||
op::ConfigureLog::setPriorityThreshold((op::Priority)FLAGS_logging_level);
|
||||
op::Profiler::setDefaultX(FLAGS_profile_speed);
|
||||
|
||||
// Applying user defined configuration - GFlags to program variables
|
||||
// outputSize
|
||||
const auto outputSize = op::flagsToPoint(FLAGS_output_resolution, "-1x-1");
|
||||
// netInputSize
|
||||
const auto netInputSize = op::flagsToPoint(FLAGS_net_resolution, "-1x368");
|
||||
// faceNetInputSize
|
||||
const auto faceNetInputSize = op::flagsToPoint(FLAGS_face_net_resolution, "368x368 (multiples of 16)");
|
||||
// handNetInputSize
|
||||
const auto handNetInputSize = op::flagsToPoint(FLAGS_hand_net_resolution, "368x368 (multiples of 16)");
|
||||
// producerType
|
||||
const auto producerSharedPtr = op::flagsToProducer(FLAGS_image_dir, FLAGS_video, FLAGS_ip_camera, FLAGS_camera,
|
||||
FLAGS_flir_camera, FLAGS_camera_resolution, FLAGS_camera_fps,
|
||||
FLAGS_camera_parameter_folder, !FLAGS_frame_keep_distortion,
|
||||
(unsigned int) FLAGS_3d_views, FLAGS_flir_camera_index);
|
||||
// poseModel
|
||||
const auto poseModel = op::flagsToPoseModel(FLAGS_model_pose);
|
||||
// JSON saving
|
||||
if (!FLAGS_write_keypoint.empty())
|
||||
op::log("Flag `write_keypoint` is deprecated and will eventually be removed."
|
||||
" Please, use `write_json` instead.", op::Priority::Max);
|
||||
// keypointScale
|
||||
const auto keypointScale = op::flagsToScaleMode(FLAGS_keypoint_scale);
|
||||
// heatmaps to add
|
||||
const auto heatMapTypes = op::flagsToHeatMaps(FLAGS_heatmaps_add_parts, FLAGS_heatmaps_add_bkg,
|
||||
FLAGS_heatmaps_add_PAFs);
|
||||
const auto heatMapScale = op::flagsToHeatMapScaleMode(FLAGS_heatmaps_scale);
|
||||
// >1 camera view?
|
||||
const auto multipleView = (FLAGS_3d || FLAGS_3d_views > 1 || FLAGS_flir_camera);
|
||||
// Enabling Google Logging
|
||||
const bool enableGoogleLogging = true;
|
||||
// Logging
|
||||
op::log("", op::Priority::Low, __LINE__, __FUNCTION__, __FILE__);
|
||||
|
||||
// Configure OpenPose
|
||||
op::log("Configuring OpenPose wrapper...", op::Priority::Low, __LINE__, __FUNCTION__, __FILE__);
|
||||
op::Wrapper<std::vector<UserDatum>> opWrapper{op::ThreadManagerMode::AsynchronousOut};
|
||||
// Pose configuration (use WrapperStructPose{} for default and recommended configuration)
|
||||
const op::WrapperStructPose wrapperStructPose{
|
||||
!FLAGS_body_disable, netInputSize, outputSize, keypointScale, FLAGS_num_gpu, FLAGS_num_gpu_start,
|
||||
FLAGS_scale_number, (float)FLAGS_scale_gap, op::flagsToRenderMode(FLAGS_render_pose, multipleView),
|
||||
poseModel, !FLAGS_disable_blending, (float)FLAGS_alpha_pose, (float)FLAGS_alpha_heatmap,
|
||||
FLAGS_part_to_show, FLAGS_model_folder, heatMapTypes, heatMapScale, FLAGS_part_candidates,
|
||||
(float)FLAGS_render_threshold, FLAGS_number_people_max, enableGoogleLogging};
|
||||
// Face configuration (use op::WrapperStructFace{} to disable it)
|
||||
const op::WrapperStructFace wrapperStructFace{
|
||||
FLAGS_face, faceNetInputSize, op::flagsToRenderMode(FLAGS_face_render, multipleView, FLAGS_render_pose),
|
||||
(float)FLAGS_face_alpha_pose, (float)FLAGS_face_alpha_heatmap, (float)FLAGS_face_render_threshold};
|
||||
// Hand configuration (use op::WrapperStructHand{} to disable it)
|
||||
const op::WrapperStructHand wrapperStructHand{
|
||||
FLAGS_hand, handNetInputSize, FLAGS_hand_scale_number, (float)FLAGS_hand_scale_range, FLAGS_hand_tracking,
|
||||
op::flagsToRenderMode(FLAGS_hand_render, multipleView, FLAGS_render_pose), (float)FLAGS_hand_alpha_pose,
|
||||
(float)FLAGS_hand_alpha_heatmap, (float)FLAGS_hand_render_threshold};
|
||||
// Extra functionality configuration (use op::WrapperStructExtra{} to disable it)
|
||||
const op::WrapperStructExtra wrapperStructExtra{
|
||||
FLAGS_3d, FLAGS_3d_min_views, FLAGS_identification, FLAGS_tracking, FLAGS_ik_threads};
|
||||
// Producer (use default to disable any input)
|
||||
const op::WrapperStructInput wrapperStructInput{
|
||||
producerSharedPtr, FLAGS_frame_first, FLAGS_frame_last, FLAGS_process_real_time, FLAGS_frame_flip,
|
||||
FLAGS_frame_rotate, FLAGS_frames_repeat};
|
||||
// Consumer (comment or use default argument to disable any output)
|
||||
const auto displayMode = op::DisplayMode::NoDisplay;
|
||||
const bool guiVerbose = false;
|
||||
const bool fullScreen = false;
|
||||
const op::WrapperStructOutput wrapperStructOutput{
|
||||
displayMode, guiVerbose, fullScreen, FLAGS_write_keypoint,
|
||||
op::stringToDataFormat(FLAGS_write_keypoint_format), FLAGS_write_json, FLAGS_write_coco_json,
|
||||
FLAGS_write_coco_foot_json, FLAGS_write_images, FLAGS_write_images_format, FLAGS_write_video,
|
||||
FLAGS_camera_fps, FLAGS_write_heatmaps, FLAGS_write_heatmaps_format, FLAGS_write_video_adam,
|
||||
FLAGS_write_bvh, FLAGS_udp_host, FLAGS_udp_port};
|
||||
// Configure wrapper
|
||||
opWrapper.configure(wrapperStructPose, wrapperStructFace, wrapperStructHand, wrapperStructExtra,
|
||||
wrapperStructInput, wrapperStructOutput);
|
||||
// Set to single-thread (for sequential processing and/or debugging and/or reducing latency)
|
||||
if (FLAGS_disable_multi_thread)
|
||||
opWrapper.disableMultiThreading();
|
||||
|
||||
op::log("Starting thread(s)...", op::Priority::High);
|
||||
opWrapper.start();
|
||||
|
||||
// User processing
|
||||
UserOutputClass userOutputClass;
|
||||
bool userWantsToExit = false;
|
||||
while (!userWantsToExit)
|
||||
{
|
||||
// Pop frame
|
||||
std::shared_ptr<std::vector<UserDatum>> datumProcessed;
|
||||
if (opWrapper.waitAndPop(datumProcessed))
|
||||
{
|
||||
userWantsToExit = userOutputClass.display(datumProcessed);;
|
||||
userOutputClass.printKeypoints(datumProcessed);
|
||||
}
|
||||
else
|
||||
op::log("Processed datum could not be emplaced.", op::Priority::High, __LINE__, __FUNCTION__, __FILE__);
|
||||
}
|
||||
|
||||
op::log("Stopping thread(s)", op::Priority::High);
|
||||
opWrapper.stop();
|
||||
|
||||
// Measuring total time
|
||||
const auto now = std::chrono::high_resolution_clock::now();
|
||||
const auto totalTimeSec = (double)std::chrono::duration_cast<std::chrono::nanoseconds>(now-timerBegin).count()
|
||||
* 1e-9;
|
||||
const auto message = "OpenPose demo successfully finished. Total time: "
|
||||
+ std::to_string(totalTimeSec) + " seconds.";
|
||||
op::log(message, op::Priority::High);
|
||||
|
||||
// Return successful message
|
||||
return 0;
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
op::error(e.what(), __LINE__, __FUNCTION__, __FILE__);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// Parsing command line flags
|
||||
gflags::ParseCommandLineFlags(&argc, &argv, true);
|
||||
|
||||
// Running openPoseTutorialWrapper1
|
||||
return openPoseTutorialWrapper1();
|
||||
}
|
||||
@@ -0,0 +1,222 @@
|
||||
// ------------------------- OpenPose Library Tutorial - Real Time Pose Estimation -------------------------
|
||||
// If the user wants to learn to use the OpenPose library, we highly recommend to start with the
|
||||
// examples in `examples/tutorial_api_cpp/`.
|
||||
// This example summarizes all the functionality of the OpenPose library:
|
||||
// 1. Read folder of images / video / webcam (`producer` module)
|
||||
// 2. Extract and render body keypoint / heatmap / PAF of that image (`pose` module)
|
||||
// 3. Extract and render face keypoint / heatmap / PAF of that image (`face` module)
|
||||
// 4. Save the results on disk (`filestream` module)
|
||||
// 5. Display the rendered pose (`gui` module)
|
||||
// Everything in a multi-thread scenario (`thread` module)
|
||||
// Points 2 to 5 are included in the `wrapper` module
|
||||
// In addition to the previous OpenPose modules, we also need to use:
|
||||
// 1. `core` module:
|
||||
// For the Array<float> class that the `pose` module needs
|
||||
// For the Datum struct that the `thread` module sends between the queues
|
||||
// 2. `utilities` module: for the error & logging functions, i.e. op::error & op::log respectively
|
||||
// This file should only be used for the user to take specific examples.
|
||||
|
||||
// Command-line user intraface
|
||||
#include <openpose/flags.hpp>
|
||||
// OpenPose dependencies
|
||||
#include <openpose/headers.hpp>
|
||||
|
||||
// If the user needs his own variables, he can inherit the op::Datum struct and add them
|
||||
// UserDatum can be directly used by the OpenPose wrapper because it inherits from op::Datum, just define
|
||||
// Wrapper<UserDatum> instead of Wrapper<op::Datum>
|
||||
struct UserDatum : public op::Datum
|
||||
{
|
||||
bool boolThatUserNeedsForSomeReason;
|
||||
|
||||
UserDatum(const bool boolThatUserNeedsForSomeReason_ = false) :
|
||||
boolThatUserNeedsForSomeReason{boolThatUserNeedsForSomeReason_}
|
||||
{}
|
||||
};
|
||||
|
||||
// The W-classes can be implemented either as a template or as simple classes given
|
||||
// that the user usually knows which kind of data he will move between the queues,
|
||||
// in this case we assume a std::shared_ptr of a std::vector of UserDatum
|
||||
|
||||
// This worker will just invert the image
|
||||
class WUserPostProcessing : public op::Worker<std::shared_ptr<std::vector<UserDatum>>>
|
||||
{
|
||||
public:
|
||||
WUserPostProcessing()
|
||||
{
|
||||
// User's constructor here
|
||||
}
|
||||
|
||||
void initializationOnThread() {}
|
||||
|
||||
void work(std::shared_ptr<std::vector<UserDatum>>& datumsPtr)
|
||||
{
|
||||
// User's post-processing (after OpenPose processing & before OpenPose outputs) here
|
||||
// datum.cvOutputData: rendered frame with pose or heatmaps
|
||||
// datum.poseKeypoints: Array<float> with the estimated pose
|
||||
try
|
||||
{
|
||||
if (datumsPtr != nullptr && !datumsPtr->empty())
|
||||
for (auto& datum : *datumsPtr)
|
||||
cv::bitwise_not(datum.cvOutputData, datum.cvOutputData);
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
this->stop();
|
||||
op::error(e.what(), __LINE__, __FUNCTION__, __FILE__);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int openPoseDemo()
|
||||
{
|
||||
try
|
||||
{
|
||||
op::log("Starting OpenPose demo...", op::Priority::High);
|
||||
const auto timerBegin = std::chrono::high_resolution_clock::now();
|
||||
|
||||
// logging_level
|
||||
op::check(0 <= FLAGS_logging_level && FLAGS_logging_level <= 255, "Wrong logging_level value.",
|
||||
__LINE__, __FUNCTION__, __FILE__);
|
||||
op::ConfigureLog::setPriorityThreshold((op::Priority)FLAGS_logging_level);
|
||||
op::Profiler::setDefaultX(FLAGS_profile_speed);
|
||||
// // For debugging
|
||||
// // Print all logging messages
|
||||
// op::ConfigureLog::setPriorityThreshold(op::Priority::None);
|
||||
// // Print out speed values faster
|
||||
// op::Profiler::setDefaultX(100);
|
||||
|
||||
// Applying user defined configuration - GFlags to program variables
|
||||
// outputSize
|
||||
const auto outputSize = op::flagsToPoint(FLAGS_output_resolution, "-1x-1");
|
||||
// netInputSize
|
||||
const auto netInputSize = op::flagsToPoint(FLAGS_net_resolution, "-1x368");
|
||||
// faceNetInputSize
|
||||
const auto faceNetInputSize = op::flagsToPoint(FLAGS_face_net_resolution, "368x368 (multiples of 16)");
|
||||
// handNetInputSize
|
||||
const auto handNetInputSize = op::flagsToPoint(FLAGS_hand_net_resolution, "368x368 (multiples of 16)");
|
||||
// producerType
|
||||
const auto producerSharedPtr = op::flagsToProducer(FLAGS_image_dir, FLAGS_video, FLAGS_ip_camera, FLAGS_camera,
|
||||
FLAGS_flir_camera, FLAGS_camera_resolution, FLAGS_camera_fps,
|
||||
FLAGS_camera_parameter_folder, !FLAGS_frame_keep_distortion,
|
||||
(unsigned int) FLAGS_3d_views, FLAGS_flir_camera_index);
|
||||
// poseModel
|
||||
const auto poseModel = op::flagsToPoseModel(FLAGS_model_pose);
|
||||
// JSON saving
|
||||
if (!FLAGS_write_keypoint.empty())
|
||||
op::log("Flag `write_keypoint` is deprecated and will eventually be removed."
|
||||
" Please, use `write_json` instead.", op::Priority::Max);
|
||||
// keypointScale
|
||||
const auto keypointScale = op::flagsToScaleMode(FLAGS_keypoint_scale);
|
||||
// heatmaps to add
|
||||
const auto heatMapTypes = op::flagsToHeatMaps(FLAGS_heatmaps_add_parts, FLAGS_heatmaps_add_bkg,
|
||||
FLAGS_heatmaps_add_PAFs);
|
||||
const auto heatMapScale = op::flagsToHeatMapScaleMode(FLAGS_heatmaps_scale);
|
||||
// >1 camera view?
|
||||
const auto multipleView = (FLAGS_3d || FLAGS_3d_views > 1 || FLAGS_flir_camera);
|
||||
// Enabling Google Logging
|
||||
const bool enableGoogleLogging = true;
|
||||
// Logging
|
||||
op::log("", op::Priority::Low, __LINE__, __FUNCTION__, __FILE__);
|
||||
|
||||
// OpenPose wrapper
|
||||
op::log("Configuring OpenPose wrapper...", op::Priority::Low, __LINE__, __FUNCTION__, __FILE__);
|
||||
// op::Wrapper<std::vector<op::Datum>> opWrapper;
|
||||
op::Wrapper<std::vector<UserDatum>> opWrapper;
|
||||
|
||||
// Initializing the user custom classes
|
||||
// Processing
|
||||
auto wUserPostProcessing = std::make_shared<WUserPostProcessing>();
|
||||
// Add custom processing
|
||||
const auto workerProcessingOnNewThread = true;
|
||||
opWrapper.setWorker(op::WorkerType::PostProcessing, wUserPostProcessing, workerProcessingOnNewThread);
|
||||
|
||||
// Pose configuration (use WrapperStructPose{} for default and recommended configuration)
|
||||
const op::WrapperStructPose wrapperStructPose{
|
||||
!FLAGS_body_disable, netInputSize, outputSize, keypointScale, FLAGS_num_gpu, FLAGS_num_gpu_start,
|
||||
FLAGS_scale_number, (float)FLAGS_scale_gap, op::flagsToRenderMode(FLAGS_render_pose, multipleView),
|
||||
poseModel, !FLAGS_disable_blending, (float)FLAGS_alpha_pose, (float)FLAGS_alpha_heatmap,
|
||||
FLAGS_part_to_show, FLAGS_model_folder, heatMapTypes, heatMapScale, FLAGS_part_candidates,
|
||||
(float)FLAGS_render_threshold, FLAGS_number_people_max, enableGoogleLogging};
|
||||
// Face configuration (use op::WrapperStructFace{} to disable it)
|
||||
const op::WrapperStructFace wrapperStructFace{
|
||||
FLAGS_face, faceNetInputSize, op::flagsToRenderMode(FLAGS_face_render, multipleView, FLAGS_render_pose),
|
||||
(float)FLAGS_face_alpha_pose, (float)FLAGS_face_alpha_heatmap, (float)FLAGS_face_render_threshold};
|
||||
// Hand configuration (use op::WrapperStructHand{} to disable it)
|
||||
const op::WrapperStructHand wrapperStructHand{
|
||||
FLAGS_hand, handNetInputSize, FLAGS_hand_scale_number, (float)FLAGS_hand_scale_range, FLAGS_hand_tracking,
|
||||
op::flagsToRenderMode(FLAGS_hand_render, multipleView, FLAGS_render_pose), (float)FLAGS_hand_alpha_pose,
|
||||
(float)FLAGS_hand_alpha_heatmap, (float)FLAGS_hand_render_threshold};
|
||||
// Producer (use default to disable any input)
|
||||
const op::WrapperStructInput wrapperStructInput{
|
||||
producerSharedPtr, FLAGS_frame_first, FLAGS_frame_last, FLAGS_process_real_time, FLAGS_frame_flip,
|
||||
FLAGS_frame_rotate, FLAGS_frames_repeat};
|
||||
// Extra functionality configuration (use op::WrapperStructExtra{} to disable it)
|
||||
const op::WrapperStructExtra wrapperStructExtra{
|
||||
FLAGS_3d, FLAGS_3d_min_views, FLAGS_identification, FLAGS_tracking, FLAGS_ik_threads};
|
||||
// Consumer (comment or use default argument to disable any output)
|
||||
const op::WrapperStructOutput wrapperStructOutput{
|
||||
op::flagsToDisplayMode(FLAGS_display, FLAGS_3d), !FLAGS_no_gui_verbose, FLAGS_fullscreen,
|
||||
FLAGS_write_keypoint, op::stringToDataFormat(FLAGS_write_keypoint_format), FLAGS_write_json,
|
||||
FLAGS_write_coco_json, FLAGS_write_coco_foot_json, FLAGS_write_images, FLAGS_write_images_format,
|
||||
FLAGS_write_video, FLAGS_camera_fps, FLAGS_write_heatmaps, FLAGS_write_heatmaps_format,
|
||||
FLAGS_write_video_adam, FLAGS_write_bvh, FLAGS_udp_host, FLAGS_udp_port};
|
||||
// Configure wrapper
|
||||
opWrapper.configure(wrapperStructPose, wrapperStructFace, wrapperStructHand, wrapperStructExtra,
|
||||
wrapperStructInput, wrapperStructOutput);
|
||||
// Set to single-thread (for sequential processing and/or debugging and/or reducing latency)
|
||||
if (FLAGS_disable_multi_thread)
|
||||
opWrapper.disableMultiThreading();
|
||||
|
||||
// Start processing
|
||||
// Two different ways of running the program on multithread environment
|
||||
op::log("Starting thread(s)...", op::Priority::High);
|
||||
// Start, run & stop threads - it blocks this thread until all others have finished
|
||||
opWrapper.exec();
|
||||
|
||||
// // Option b) Keeping this thread free in case you want to do something else meanwhile, e.g. profiling the GPU
|
||||
// memory
|
||||
// // VERY IMPORTANT NOTE: if OpenCV is compiled with Qt support, this option will not work. Qt needs the main
|
||||
// // thread to plot visual results, so the final GUI (which uses OpenCV) would return an exception similar to:
|
||||
// // `QMetaMethod::invoke: Unable to invoke methods with return values in queued connections`
|
||||
// // Start threads
|
||||
// opWrapper.start();
|
||||
// // Profile used GPU memory
|
||||
// // 1: wait ~10sec so the memory has been totally loaded on GPU
|
||||
// // 2: profile the GPU memory
|
||||
// const auto sleepTimeMs = 10;
|
||||
// for (auto i = 0 ; i < 10000/sleepTimeMs && opWrapper.isRunning() ; i++)
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds{sleepTimeMs});
|
||||
// op::Profiler::profileGpuMemory(__LINE__, __FUNCTION__, __FILE__);
|
||||
// // Keep program alive while running threads
|
||||
// while (opWrapper.isRunning())
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds{sleepTimeMs});
|
||||
// // Stop and join threads
|
||||
// op::log("Stopping thread(s)", op::Priority::High);
|
||||
// opWrapper.stop();
|
||||
|
||||
// Measuring total time
|
||||
const auto now = std::chrono::high_resolution_clock::now();
|
||||
const auto totalTimeSec = (double)std::chrono::duration_cast<std::chrono::nanoseconds>(now-timerBegin).count()
|
||||
* 1e-9;
|
||||
const auto message = "OpenPose demo successfully finished. Total time: "
|
||||
+ std::to_string(totalTimeSec) + " seconds.";
|
||||
op::log(message, op::Priority::High);
|
||||
|
||||
// Return successful message
|
||||
return 0;
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
op::error(e.what(), __LINE__, __FUNCTION__, __FILE__);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// Parsing command line flags
|
||||
gflags::ParseCommandLineFlags(&argc, &argv, true);
|
||||
|
||||
// Running openPoseDemo
|
||||
return openPoseDemo();
|
||||
}
|
||||
@@ -0,0 +1,266 @@
|
||||
// ------------------------- OpenPose Library Tutorial - Real Time Pose Estimation -------------------------
|
||||
// If the user wants to learn to use the OpenPose library, we highly recommend to start with the
|
||||
// examples in `examples/tutorial_api_cpp/`.
|
||||
// This example summarizes all the functionality of the OpenPose library:
|
||||
// 1. Read folder of images / video / webcam (`producer` module)
|
||||
// 2. Extract and render body keypoint / heatmap / PAF of that image (`pose` module)
|
||||
// 3. Extract and render face keypoint / heatmap / PAF of that image (`face` module)
|
||||
// 4. Save the results on disk (`filestream` module)
|
||||
// 5. Display the rendered pose (`gui` module)
|
||||
// Everything in a multi-thread scenario (`thread` module)
|
||||
// Points 2 to 5 are included in the `wrapper` module
|
||||
// In addition to the previous OpenPose modules, we also need to use:
|
||||
// 1. `core` module:
|
||||
// For the Array<float> class that the `pose` module needs
|
||||
// For the Datum struct that the `thread` module sends between the queues
|
||||
// 2. `utilities` module: for the error & logging functions, i.e. op::error & op::log respectively
|
||||
// This file should only be used for the user to take specific examples.
|
||||
|
||||
// Command-line user intraface
|
||||
#define OPENPOSE_FLAGS_DISABLE_PRODUCER
|
||||
#include <openpose/flags.hpp>
|
||||
// OpenPose dependencies
|
||||
#include <openpose/headers.hpp>
|
||||
|
||||
// Custom OpenPose flags
|
||||
// Producer
|
||||
DEFINE_string(image_dir, "examples/media/",
|
||||
"Process a directory of images. Read all standard formats (jpg, png, bmp, etc.).");
|
||||
|
||||
// If the user needs his own variables, he can inherit the op::Datum struct and add them
|
||||
// UserDatum can be directly used by the OpenPose wrapper because it inherits from op::Datum, just define
|
||||
// Wrapper<UserDatum> instead of Wrapper<op::Datum>
|
||||
struct UserDatum : public op::Datum
|
||||
{
|
||||
bool boolThatUserNeedsForSomeReason;
|
||||
|
||||
UserDatum(const bool boolThatUserNeedsForSomeReason_ = false) :
|
||||
boolThatUserNeedsForSomeReason{boolThatUserNeedsForSomeReason_}
|
||||
{}
|
||||
};
|
||||
|
||||
// The W-classes can be implemented either as a template or as simple classes given
|
||||
// that the user usually knows which kind of data he will move between the queues,
|
||||
// in this case we assume a std::shared_ptr of a std::vector of UserDatum
|
||||
|
||||
// This worker will just read and return all the jpg files in a directory
|
||||
class WUserInput : public op::WorkerProducer<std::shared_ptr<std::vector<UserDatum>>>
|
||||
{
|
||||
public:
|
||||
WUserInput(const std::string& directoryPath) :
|
||||
mImageFiles{op::getFilesOnDirectory(directoryPath, "jpg")},
|
||||
// If we want "jpg" + "png" images
|
||||
// mImageFiles{op::getFilesOnDirectory(directoryPath, std::vector<std::string>{"jpg", "png"})},
|
||||
mCounter{0}
|
||||
{
|
||||
if (mImageFiles.empty())
|
||||
op::error("No images found on: " + directoryPath, __LINE__, __FUNCTION__, __FILE__);
|
||||
}
|
||||
|
||||
void initializationOnThread() {}
|
||||
|
||||
std::shared_ptr<std::vector<UserDatum>> workProducer()
|
||||
{
|
||||
try
|
||||
{
|
||||
// Close program when empty frame
|
||||
if (mImageFiles.size() <= mCounter)
|
||||
{
|
||||
op::log("Last frame read and added to queue. Closing program after it is processed.",
|
||||
op::Priority::High);
|
||||
// This funtion stops this worker, which will eventually stop the whole thread system once all the
|
||||
// frames have been processed
|
||||
this->stop();
|
||||
return nullptr;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Create new datum
|
||||
auto datumsPtr = std::make_shared<std::vector<UserDatum>>();
|
||||
datumsPtr->emplace_back();
|
||||
auto& datum = datumsPtr->at(0);
|
||||
|
||||
// Fill datum
|
||||
datum.cvInputData = cv::imread(mImageFiles.at(mCounter++));
|
||||
|
||||
// If empty frame -> return nullptr
|
||||
if (datum.cvInputData.empty())
|
||||
{
|
||||
op::log("Empty frame detected on path: " + mImageFiles.at(mCounter-1) + ". Closing program.",
|
||||
op::Priority::High);
|
||||
this->stop();
|
||||
datumsPtr = nullptr;
|
||||
}
|
||||
|
||||
return datumsPtr;
|
||||
}
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
this->stop();
|
||||
op::error(e.what(), __LINE__, __FUNCTION__, __FILE__);
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
const std::vector<std::string> mImageFiles;
|
||||
unsigned long long mCounter;
|
||||
};
|
||||
|
||||
int openPoseDemo()
|
||||
{
|
||||
try
|
||||
{
|
||||
op::log("Starting OpenPose demo...", op::Priority::High);
|
||||
const auto timerBegin = std::chrono::high_resolution_clock::now();
|
||||
|
||||
// logging_level
|
||||
op::check(0 <= FLAGS_logging_level && FLAGS_logging_level <= 255, "Wrong logging_level value.",
|
||||
__LINE__, __FUNCTION__, __FILE__);
|
||||
op::ConfigureLog::setPriorityThreshold((op::Priority)FLAGS_logging_level);
|
||||
op::Profiler::setDefaultX(FLAGS_profile_speed);
|
||||
// // For debugging
|
||||
// // Print all logging messages
|
||||
// op::ConfigureLog::setPriorityThreshold(op::Priority::None);
|
||||
// // Print out speed values faster
|
||||
// op::Profiler::setDefaultX(100);
|
||||
|
||||
// Applying user defined configuration - GFlags to program variables
|
||||
// outputSize
|
||||
const auto outputSize = op::flagsToPoint(FLAGS_output_resolution, "-1x-1");
|
||||
// netInputSize
|
||||
const auto netInputSize = op::flagsToPoint(FLAGS_net_resolution, "-1x368");
|
||||
// faceNetInputSize
|
||||
const auto faceNetInputSize = op::flagsToPoint(FLAGS_face_net_resolution, "368x368 (multiples of 16)");
|
||||
// handNetInputSize
|
||||
const auto handNetInputSize = op::flagsToPoint(FLAGS_hand_net_resolution, "368x368 (multiples of 16)");
|
||||
// // producerType
|
||||
// const auto producerSharedPtr = op::flagsToProducer(FLAGS_image_dir, FLAGS_video, FLAGS_ip_camera, FLAGS_camera,
|
||||
// FLAGS_flir_camera, FLAGS_camera_resolution, FLAGS_camera_fps,
|
||||
// FLAGS_camera_parameter_folder, !FLAGS_frame_keep_distortion,
|
||||
// (unsigned int) FLAGS_3d_views, FLAGS_flir_camera_index);
|
||||
// poseModel
|
||||
const auto poseModel = op::flagsToPoseModel(FLAGS_model_pose);
|
||||
// JSON saving
|
||||
if (!FLAGS_write_keypoint.empty())
|
||||
op::log("Flag `write_keypoint` is deprecated and will eventually be removed."
|
||||
" Please, use `write_json` instead.", op::Priority::Max);
|
||||
// keypointScale
|
||||
const auto keypointScale = op::flagsToScaleMode(FLAGS_keypoint_scale);
|
||||
// heatmaps to add
|
||||
const auto heatMapTypes = op::flagsToHeatMaps(FLAGS_heatmaps_add_parts, FLAGS_heatmaps_add_bkg,
|
||||
FLAGS_heatmaps_add_PAFs);
|
||||
const auto heatMapScale = op::flagsToHeatMapScaleMode(FLAGS_heatmaps_scale);
|
||||
// >1 camera view?
|
||||
// const auto multipleView = (FLAGS_3d || FLAGS_3d_views > 1 || FLAGS_flir_camera);
|
||||
const auto multipleView = false;
|
||||
// Enabling Google Logging
|
||||
const bool enableGoogleLogging = true;
|
||||
// Logging
|
||||
op::log("", op::Priority::Low, __LINE__, __FUNCTION__, __FILE__);
|
||||
|
||||
// OpenPose wrapper
|
||||
op::log("Configuring OpenPose wrapper...", op::Priority::Low, __LINE__, __FUNCTION__, __FILE__);
|
||||
// op::Wrapper<std::vector<op::Datum>> opWrapper;
|
||||
op::Wrapper<std::vector<UserDatum>> opWrapper;
|
||||
|
||||
// Initializing the user custom classes
|
||||
// Frames producer (e.g. video, webcam, ...)
|
||||
auto wUserInput = std::make_shared<WUserInput>(FLAGS_image_dir);
|
||||
// Add custom processing
|
||||
const auto workerInputOnNewThread = true;
|
||||
opWrapper.setWorker(op::WorkerType::Input, wUserInput, workerInputOnNewThread);
|
||||
|
||||
// Pose configuration (use WrapperStructPose{} for default and recommended configuration)
|
||||
const op::WrapperStructPose wrapperStructPose{
|
||||
!FLAGS_body_disable, netInputSize, outputSize, keypointScale, FLAGS_num_gpu, FLAGS_num_gpu_start,
|
||||
FLAGS_scale_number, (float)FLAGS_scale_gap, op::flagsToRenderMode(FLAGS_render_pose, multipleView),
|
||||
poseModel, !FLAGS_disable_blending, (float)FLAGS_alpha_pose, (float)FLAGS_alpha_heatmap,
|
||||
FLAGS_part_to_show, FLAGS_model_folder, heatMapTypes, heatMapScale, FLAGS_part_candidates,
|
||||
(float)FLAGS_render_threshold, FLAGS_number_people_max, enableGoogleLogging};
|
||||
// Face configuration (use op::WrapperStructFace{} to disable it)
|
||||
const op::WrapperStructFace wrapperStructFace{
|
||||
FLAGS_face, faceNetInputSize, op::flagsToRenderMode(FLAGS_face_render, multipleView, FLAGS_render_pose),
|
||||
(float)FLAGS_face_alpha_pose, (float)FLAGS_face_alpha_heatmap, (float)FLAGS_face_render_threshold};
|
||||
// Hand configuration (use op::WrapperStructHand{} to disable it)
|
||||
const op::WrapperStructHand wrapperStructHand{
|
||||
FLAGS_hand, handNetInputSize, FLAGS_hand_scale_number, (float)FLAGS_hand_scale_range, FLAGS_hand_tracking,
|
||||
op::flagsToRenderMode(FLAGS_hand_render, multipleView, FLAGS_render_pose), (float)FLAGS_hand_alpha_pose,
|
||||
(float)FLAGS_hand_alpha_heatmap, (float)FLAGS_hand_render_threshold};
|
||||
// Extra functionality configuration (use op::WrapperStructExtra{} to disable it)
|
||||
const op::WrapperStructExtra wrapperStructExtra{
|
||||
FLAGS_3d, FLAGS_3d_min_views, FLAGS_identification, FLAGS_tracking, FLAGS_ik_threads};
|
||||
// Producer (use default to disable any input)
|
||||
// const op::WrapperStructInput wrapperStructInput{producerSharedPtr, FLAGS_frame_first, FLAGS_frame_last,
|
||||
// FLAGS_process_real_time, FLAGS_frame_flip, FLAGS_frame_rotate,
|
||||
// FLAGS_frames_repeat};
|
||||
const op::WrapperStructInput wrapperStructInput;
|
||||
// Consumer (comment or use default argument to disable any output)
|
||||
const op::WrapperStructOutput wrapperStructOutput{
|
||||
op::flagsToDisplayMode(FLAGS_display, FLAGS_3d), !FLAGS_no_gui_verbose, FLAGS_fullscreen,
|
||||
FLAGS_write_keypoint, op::stringToDataFormat(FLAGS_write_keypoint_format), FLAGS_write_json,
|
||||
FLAGS_write_coco_json, FLAGS_write_coco_foot_json, FLAGS_write_images, FLAGS_write_images_format,
|
||||
FLAGS_write_video, FLAGS_camera_fps, FLAGS_write_heatmaps, FLAGS_write_heatmaps_format,
|
||||
FLAGS_write_video_adam, FLAGS_write_bvh, FLAGS_udp_host, FLAGS_udp_port};
|
||||
// Configure wrapper
|
||||
|
||||
opWrapper.configure(wrapperStructPose, wrapperStructFace, wrapperStructHand, wrapperStructExtra,
|
||||
wrapperStructInput, wrapperStructOutput);
|
||||
// Set to single-thread (for sequential processing and/or debugging and/or reducing latency)
|
||||
if (FLAGS_disable_multi_thread)
|
||||
opWrapper.disableMultiThreading();
|
||||
|
||||
// Start processing
|
||||
// Two different ways of running the program on multithread environment
|
||||
op::log("Starting thread(s)...", op::Priority::High);
|
||||
// Start, run & stop threads - it blocks this thread until all others have finished
|
||||
opWrapper.exec();
|
||||
|
||||
// // Option b) Keeping this thread free in case you want to do something else meanwhile, e.g. profiling the GPU
|
||||
// memory
|
||||
// // VERY IMPORTANT NOTE: if OpenCV is compiled with Qt support, this option will not work. Qt needs the main
|
||||
// // thread to plot visual results, so the final GUI (which uses OpenCV) would return an exception similar to:
|
||||
// // `QMetaMethod::invoke: Unable to invoke methods with return values in queued connections`
|
||||
// // Start threads
|
||||
// opWrapper.start();
|
||||
// // Profile used GPU memory
|
||||
// // 1: wait ~10sec so the memory has been totally loaded on GPU
|
||||
// // 2: profile the GPU memory
|
||||
// const auto sleepTimeMs = 10;
|
||||
// for (auto i = 0 ; i < 10000/sleepTimeMs && opWrapper.isRunning() ; i++)
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds{sleepTimeMs});
|
||||
// op::Profiler::profileGpuMemory(__LINE__, __FUNCTION__, __FILE__);
|
||||
// // Keep program alive while running threads
|
||||
// while (opWrapper.isRunning())
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds{sleepTimeMs});
|
||||
// // Stop and join threads
|
||||
// op::log("Stopping thread(s)", op::Priority::High);
|
||||
// opWrapper.stop();
|
||||
|
||||
// Measuring total time
|
||||
const auto now = std::chrono::high_resolution_clock::now();
|
||||
const auto totalTimeSec = (double)std::chrono::duration_cast<std::chrono::nanoseconds>(now-timerBegin).count()
|
||||
* 1e-9;
|
||||
const auto message = "OpenPose demo successfully finished. Total time: "
|
||||
+ std::to_string(totalTimeSec) + " seconds.";
|
||||
op::log(message, op::Priority::High);
|
||||
|
||||
// Return successful message
|
||||
return 0;
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
op::error(e.what(), __LINE__, __FUNCTION__, __FILE__);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// Parsing command line flags
|
||||
gflags::ParseCommandLineFlags(&argc, &argv, true);
|
||||
|
||||
// Running openPoseDemo
|
||||
return openPoseDemo();
|
||||
}
|
||||
@@ -0,0 +1,274 @@
|
||||
// ------------------------- OpenPose Library Tutorial - Real Time Pose Estimation -------------------------
|
||||
// If the user wants to learn to use the OpenPose library, we highly recommend to start with the
|
||||
// examples in `examples/tutorial_api_cpp/`.
|
||||
// This example summarizes all the functionality of the OpenPose library:
|
||||
// 1. Read folder of images / video / webcam (`producer` module)
|
||||
// 2. Extract and render body keypoint / heatmap / PAF of that image (`pose` module)
|
||||
// 3. Extract and render face keypoint / heatmap / PAF of that image (`face` module)
|
||||
// 4. Save the results on disk (`filestream` module)
|
||||
// 5. Display the rendered pose (`gui` module)
|
||||
// Everything in a multi-thread scenario (`thread` module)
|
||||
// Points 2 to 5 are included in the `wrapper` module
|
||||
// In addition to the previous OpenPose modules, we also need to use:
|
||||
// 1. `core` module:
|
||||
// For the Array<float> class that the `pose` module needs
|
||||
// For the Datum struct that the `thread` module sends between the queues
|
||||
// 2. `utilities` module: for the error & logging functions, i.e. op::error & op::log respectively
|
||||
// This file should only be used for the user to take specific examples.
|
||||
|
||||
// Command-line user intraface
|
||||
#include <openpose/flags.hpp>
|
||||
// OpenPose dependencies
|
||||
#include <openpose/headers.hpp>
|
||||
|
||||
// If the user needs his own variables, he can inherit the op::Datum struct and add them
|
||||
// UserDatum can be directly used by the OpenPose wrapper because it inherits from op::Datum, just define
|
||||
// Wrapper<UserDatum> instead of Wrapper<op::Datum>
|
||||
struct UserDatum : public op::Datum
|
||||
{
|
||||
bool boolThatUserNeedsForSomeReason;
|
||||
|
||||
UserDatum(const bool boolThatUserNeedsForSomeReason_ = false) :
|
||||
boolThatUserNeedsForSomeReason{boolThatUserNeedsForSomeReason_}
|
||||
{}
|
||||
};
|
||||
|
||||
// The W-classes can be implemented either as a template or as simple classes given
|
||||
// that the user usually knows which kind of data he will move between the queues,
|
||||
// in this case we assume a std::shared_ptr of a std::vector of UserDatum
|
||||
|
||||
// This worker will just read and return all the jpg files in a directory
|
||||
class WUserOutput : public op::WorkerConsumer<std::shared_ptr<std::vector<UserDatum>>>
|
||||
{
|
||||
public:
|
||||
void initializationOnThread() {}
|
||||
|
||||
void workConsumer(const std::shared_ptr<std::vector<UserDatum>>& datumsPtr)
|
||||
{
|
||||
try
|
||||
{
|
||||
// User's displaying/saving/other processing here
|
||||
// datum.cvOutputData: rendered frame with pose or heatmaps
|
||||
// datum.poseKeypoints: Array<float> with the estimated pose
|
||||
if (datumsPtr != nullptr && !datumsPtr->empty())
|
||||
{
|
||||
// Show in command line the resulting pose keypoints for body, face and hands
|
||||
op::log("\nKeypoints:");
|
||||
// Accesing each element of the keypoints
|
||||
const auto& poseKeypoints = datumsPtr->at(0).poseKeypoints;
|
||||
op::log("Person pose keypoints:");
|
||||
for (auto person = 0 ; person < poseKeypoints.getSize(0) ; person++)
|
||||
{
|
||||
op::log("Person " + std::to_string(person) + " (x, y, score):");
|
||||
for (auto bodyPart = 0 ; bodyPart < poseKeypoints.getSize(1) ; bodyPart++)
|
||||
{
|
||||
std::string valueToPrint;
|
||||
for (auto xyscore = 0 ; xyscore < poseKeypoints.getSize(2) ; xyscore++)
|
||||
{
|
||||
valueToPrint += std::to_string( poseKeypoints[{person, bodyPart, xyscore}] ) + " ";
|
||||
}
|
||||
op::log(valueToPrint);
|
||||
}
|
||||
}
|
||||
op::log(" ");
|
||||
// Alternative: just getting std::string equivalent
|
||||
op::log("Face keypoints: " + datumsPtr->at(0).faceKeypoints.toString());
|
||||
op::log("Left hand keypoints: " + datumsPtr->at(0).handKeypoints[0].toString());
|
||||
op::log("Right hand keypoints: " + datumsPtr->at(0).handKeypoints[1].toString());
|
||||
// Heatmaps
|
||||
const auto& poseHeatMaps = datumsPtr->at(0).poseHeatMaps;
|
||||
if (!poseHeatMaps.empty())
|
||||
{
|
||||
op::log("Pose heatmaps size: [" + std::to_string(poseHeatMaps.getSize(0)) + ", "
|
||||
+ std::to_string(poseHeatMaps.getSize(1)) + ", "
|
||||
+ std::to_string(poseHeatMaps.getSize(2)) + "]");
|
||||
const auto& faceHeatMaps = datumsPtr->at(0).faceHeatMaps;
|
||||
op::log("Face heatmaps size: [" + std::to_string(faceHeatMaps.getSize(0)) + ", "
|
||||
+ std::to_string(faceHeatMaps.getSize(1)) + ", "
|
||||
+ std::to_string(faceHeatMaps.getSize(2)) + ", "
|
||||
+ std::to_string(faceHeatMaps.getSize(3)) + "]");
|
||||
const auto& handHeatMaps = datumsPtr->at(0).handHeatMaps;
|
||||
op::log("Left hand heatmaps size: [" + std::to_string(handHeatMaps[0].getSize(0)) + ", "
|
||||
+ std::to_string(handHeatMaps[0].getSize(1)) + ", "
|
||||
+ std::to_string(handHeatMaps[0].getSize(2)) + ", "
|
||||
+ std::to_string(handHeatMaps[0].getSize(3)) + "]");
|
||||
op::log("Right hand heatmaps size: [" + std::to_string(handHeatMaps[1].getSize(0)) + ", "
|
||||
+ std::to_string(handHeatMaps[1].getSize(1)) + ", "
|
||||
+ std::to_string(handHeatMaps[1].getSize(2)) + ", "
|
||||
+ std::to_string(handHeatMaps[1].getSize(3)) + "]");
|
||||
}
|
||||
|
||||
// Display rendered output image
|
||||
cv::imshow("User worker GUI", datumsPtr->at(0).cvOutputData);
|
||||
// Display image and sleeps at least 1 ms (it usually sleeps ~5-10 msec to display the image)
|
||||
const char key = (char)cv::waitKey(1);
|
||||
if (key == 27)
|
||||
this->stop();
|
||||
}
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
this->stop();
|
||||
op::error(e.what(), __LINE__, __FUNCTION__, __FILE__);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int openPoseDemo()
|
||||
{
|
||||
try
|
||||
{
|
||||
op::log("Starting OpenPose demo...", op::Priority::High);
|
||||
const auto timerBegin = std::chrono::high_resolution_clock::now();
|
||||
|
||||
// logging_level
|
||||
op::check(0 <= FLAGS_logging_level && FLAGS_logging_level <= 255, "Wrong logging_level value.",
|
||||
__LINE__, __FUNCTION__, __FILE__);
|
||||
op::ConfigureLog::setPriorityThreshold((op::Priority)FLAGS_logging_level);
|
||||
op::Profiler::setDefaultX(FLAGS_profile_speed);
|
||||
// // For debugging
|
||||
// // Print all logging messages
|
||||
// op::ConfigureLog::setPriorityThreshold(op::Priority::None);
|
||||
// // Print out speed values faster
|
||||
// op::Profiler::setDefaultX(100);
|
||||
|
||||
// Applying user defined configuration - GFlags to program variables
|
||||
// outputSize
|
||||
const auto outputSize = op::flagsToPoint(FLAGS_output_resolution, "-1x-1");
|
||||
// netInputSize
|
||||
const auto netInputSize = op::flagsToPoint(FLAGS_net_resolution, "-1x368");
|
||||
// faceNetInputSize
|
||||
const auto faceNetInputSize = op::flagsToPoint(FLAGS_face_net_resolution, "368x368 (multiples of 16)");
|
||||
// handNetInputSize
|
||||
const auto handNetInputSize = op::flagsToPoint(FLAGS_hand_net_resolution, "368x368 (multiples of 16)");
|
||||
// producerType
|
||||
const auto producerSharedPtr = op::flagsToProducer(FLAGS_image_dir, FLAGS_video, FLAGS_ip_camera, FLAGS_camera,
|
||||
FLAGS_flir_camera, FLAGS_camera_resolution, FLAGS_camera_fps,
|
||||
FLAGS_camera_parameter_folder, !FLAGS_frame_keep_distortion,
|
||||
(unsigned int) FLAGS_3d_views, FLAGS_flir_camera_index);
|
||||
// poseModel
|
||||
const auto poseModel = op::flagsToPoseModel(FLAGS_model_pose);
|
||||
// JSON saving
|
||||
if (!FLAGS_write_keypoint.empty())
|
||||
op::log("Flag `write_keypoint` is deprecated and will eventually be removed."
|
||||
" Please, use `write_json` instead.", op::Priority::Max);
|
||||
// keypointScale
|
||||
const auto keypointScale = op::flagsToScaleMode(FLAGS_keypoint_scale);
|
||||
// heatmaps to add
|
||||
const auto heatMapTypes = op::flagsToHeatMaps(FLAGS_heatmaps_add_parts, FLAGS_heatmaps_add_bkg,
|
||||
FLAGS_heatmaps_add_PAFs);
|
||||
const auto heatMapScale = op::flagsToHeatMapScaleMode(FLAGS_heatmaps_scale);
|
||||
// >1 camera view?
|
||||
const auto multipleView = (FLAGS_3d || FLAGS_3d_views > 1 || FLAGS_flir_camera);
|
||||
// Enabling Google Logging
|
||||
const bool enableGoogleLogging = true;
|
||||
// Logging
|
||||
op::log("", op::Priority::Low, __LINE__, __FUNCTION__, __FILE__);
|
||||
|
||||
// OpenPose wrapper
|
||||
op::log("Configuring OpenPose wrapper...", op::Priority::Low, __LINE__, __FUNCTION__, __FILE__);
|
||||
// op::Wrapper<std::vector<op::Datum>> opWrapper;
|
||||
op::Wrapper<std::vector<UserDatum>> opWrapper;
|
||||
|
||||
// Initializing the user custom classes
|
||||
// GUI (Display)
|
||||
auto wUserOutput = std::make_shared<WUserOutput>();
|
||||
// Add custom processing
|
||||
const auto workerOutputOnNewThread = true;
|
||||
opWrapper.setWorker(op::WorkerType::Output, wUserOutput, workerOutputOnNewThread);
|
||||
|
||||
// Pose configuration (use WrapperStructPose{} for default and recommended configuration)
|
||||
const op::WrapperStructPose wrapperStructPose{
|
||||
!FLAGS_body_disable, netInputSize, outputSize, keypointScale, FLAGS_num_gpu, FLAGS_num_gpu_start,
|
||||
FLAGS_scale_number, (float)FLAGS_scale_gap, op::flagsToRenderMode(FLAGS_render_pose, multipleView),
|
||||
poseModel, !FLAGS_disable_blending, (float)FLAGS_alpha_pose, (float)FLAGS_alpha_heatmap,
|
||||
FLAGS_part_to_show, FLAGS_model_folder, heatMapTypes, heatMapScale, FLAGS_part_candidates,
|
||||
(float)FLAGS_render_threshold, FLAGS_number_people_max, enableGoogleLogging};
|
||||
// Face configuration (use op::WrapperStructFace{} to disable it)
|
||||
const op::WrapperStructFace wrapperStructFace{
|
||||
FLAGS_face, faceNetInputSize, op::flagsToRenderMode(FLAGS_face_render, multipleView, FLAGS_render_pose),
|
||||
(float)FLAGS_face_alpha_pose, (float)FLAGS_face_alpha_heatmap, (float)FLAGS_face_render_threshold};
|
||||
// Hand configuration (use op::WrapperStructHand{} to disable it)
|
||||
const op::WrapperStructHand wrapperStructHand{
|
||||
FLAGS_hand, handNetInputSize, FLAGS_hand_scale_number, (float)FLAGS_hand_scale_range, FLAGS_hand_tracking,
|
||||
op::flagsToRenderMode(FLAGS_hand_render, multipleView, FLAGS_render_pose), (float)FLAGS_hand_alpha_pose,
|
||||
(float)FLAGS_hand_alpha_heatmap, (float)FLAGS_hand_render_threshold};
|
||||
// Extra functionality configuration (use op::WrapperStructExtra{} to disable it)
|
||||
const op::WrapperStructExtra wrapperStructExtra{
|
||||
FLAGS_3d, FLAGS_3d_min_views, FLAGS_identification, FLAGS_tracking, FLAGS_ik_threads};
|
||||
// Producer (use default to disable any input)
|
||||
const op::WrapperStructInput wrapperStructInput{
|
||||
producerSharedPtr, FLAGS_frame_first, FLAGS_frame_last, FLAGS_process_real_time, FLAGS_frame_flip,
|
||||
FLAGS_frame_rotate, FLAGS_frames_repeat};
|
||||
// Consumer (comment or use default argument to disable any output)
|
||||
// const op::WrapperStructOutput wrapperStructOutput{op::flagsToDisplayMode(FLAGS_display, FLAGS_3d),
|
||||
// !FLAGS_no_gui_verbose, FLAGS_fullscreen, FLAGS_write_keypoint,
|
||||
const auto displayMode = op::DisplayMode::NoDisplay;
|
||||
const bool guiVerbose = false;
|
||||
const bool fullScreen = false;
|
||||
const op::WrapperStructOutput wrapperStructOutput{
|
||||
displayMode, guiVerbose, fullScreen, FLAGS_write_keypoint,
|
||||
op::stringToDataFormat(FLAGS_write_keypoint_format), FLAGS_write_json, FLAGS_write_coco_json,
|
||||
FLAGS_write_coco_foot_json, FLAGS_write_images, FLAGS_write_images_format, FLAGS_write_video,
|
||||
FLAGS_camera_fps, FLAGS_write_heatmaps, FLAGS_write_heatmaps_format, FLAGS_write_video_adam,
|
||||
FLAGS_write_bvh, FLAGS_udp_host, FLAGS_udp_port};
|
||||
// Configure wrapper
|
||||
opWrapper.configure(wrapperStructPose, wrapperStructFace, wrapperStructHand, wrapperStructExtra,
|
||||
wrapperStructInput, wrapperStructOutput);
|
||||
// Set to single-thread (for sequential processing and/or debugging and/or reducing latency)
|
||||
if (FLAGS_disable_multi_thread)
|
||||
opWrapper.disableMultiThreading();
|
||||
|
||||
// Start processing
|
||||
// Two different ways of running the program on multithread environment
|
||||
op::log("Starting thread(s)...", op::Priority::High);
|
||||
// Start, run & stop threads - it blocks this thread until all others have finished
|
||||
opWrapper.exec();
|
||||
|
||||
// // Option b) Keeping this thread free in case you want to do something else meanwhile, e.g. profiling the GPU
|
||||
// memory
|
||||
// // VERY IMPORTANT NOTE: if OpenCV is compiled with Qt support, this option will not work. Qt needs the main
|
||||
// // thread to plot visual results, so the final GUI (which uses OpenCV) would return an exception similar to:
|
||||
// // `QMetaMethod::invoke: Unable to invoke methods with return values in queued connections`
|
||||
// // Start threads
|
||||
// opWrapper.start();
|
||||
// // Profile used GPU memory
|
||||
// // 1: wait ~10sec so the memory has been totally loaded on GPU
|
||||
// // 2: profile the GPU memory
|
||||
// const auto sleepTimeMs = 10;
|
||||
// for (auto i = 0 ; i < 10000/sleepTimeMs && opWrapper.isRunning() ; i++)
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds{sleepTimeMs});
|
||||
// op::Profiler::profileGpuMemory(__LINE__, __FUNCTION__, __FILE__);
|
||||
// // Keep program alive while running threads
|
||||
// while (opWrapper.isRunning())
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds{sleepTimeMs});
|
||||
// // Stop and join threads
|
||||
// op::log("Stopping thread(s)", op::Priority::High);
|
||||
// opWrapper.stop();
|
||||
|
||||
// Measuring total time
|
||||
const auto now = std::chrono::high_resolution_clock::now();
|
||||
const auto totalTimeSec = (double)std::chrono::duration_cast<std::chrono::nanoseconds>(now-timerBegin).count()
|
||||
* 1e-9;
|
||||
const auto message = "OpenPose demo successfully finished. Total time: "
|
||||
+ std::to_string(totalTimeSec) + " seconds.";
|
||||
op::log(message, op::Priority::High);
|
||||
|
||||
// Return successful message
|
||||
return 0;
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
op::error(e.what(), __LINE__, __FUNCTION__, __FILE__);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// Parsing command line flags
|
||||
gflags::ParseCommandLineFlags(&argc, &argv, true);
|
||||
|
||||
// Running openPoseDemo
|
||||
return openPoseDemo();
|
||||
}
|
||||
@@ -0,0 +1,362 @@
|
||||
// ------------------------- OpenPose Library Tutorial - Wrapper - Example 2 - Synchronous -------------------------
|
||||
// Synchronous mode: ideal for performance. The user can add his own frames producer / post-processor / consumer to the OpenPose wrapper or use the
|
||||
// default ones.
|
||||
|
||||
// This example shows the user how to use the OpenPose wrapper class:
|
||||
// 1. User reads images
|
||||
// 2. Extract and render keypoint / heatmap / PAF of that image
|
||||
// 3. Save the results on disk
|
||||
// 4. User displays the rendered pose
|
||||
// Everything in a multi-thread scenario
|
||||
// In addition to the previous OpenPose modules, we also need to use:
|
||||
// 1. `core` module:
|
||||
// For the Array<float> class that the `pose` module needs
|
||||
// For the Datum struct that the `thread` module sends between the queues
|
||||
// 2. `utilities` module: for the error & logging functions, i.e. op::error & op::log respectively
|
||||
// This file should only be used for the user to take specific examples.
|
||||
|
||||
// Command-line user intraface
|
||||
#define OPENPOSE_FLAGS_DISABLE_PRODUCER
|
||||
#define OPENPOSE_FLAGS_DISABLE_DISPLAY
|
||||
#include <openpose/flags.hpp>
|
||||
// OpenPose dependencies
|
||||
#include <openpose/headers.hpp>
|
||||
|
||||
// Custom OpenPose flags
|
||||
// Producer
|
||||
DEFINE_string(image_dir, "examples/media/",
|
||||
"Process a directory of images. Read all standard formats (jpg, png, bmp, etc.).");
|
||||
|
||||
// If the user needs his own variables, he can inherit the op::Datum struct and add them
|
||||
// UserDatum can be directly used by the OpenPose wrapper because it inherits from op::Datum, just define
|
||||
// Wrapper<UserDatum> instead of Wrapper<op::Datum>
|
||||
struct UserDatum : public op::Datum
|
||||
{
|
||||
bool boolThatUserNeedsForSomeReason;
|
||||
|
||||
UserDatum(const bool boolThatUserNeedsForSomeReason_ = false) :
|
||||
boolThatUserNeedsForSomeReason{boolThatUserNeedsForSomeReason_}
|
||||
{}
|
||||
};
|
||||
|
||||
// The W-classes can be implemented either as a template or as simple classes given
|
||||
// that the user usually knows which kind of data he will move between the queues,
|
||||
// in this case we assume a std::shared_ptr of a std::vector of UserDatum
|
||||
|
||||
// This worker will just read and return all the jpg files in a directory
|
||||
class WUserInput : public op::WorkerProducer<std::shared_ptr<std::vector<UserDatum>>>
|
||||
{
|
||||
public:
|
||||
WUserInput(const std::string& directoryPath) :
|
||||
mImageFiles{op::getFilesOnDirectory(directoryPath, "jpg")},
|
||||
// If we want "jpg" + "png" images
|
||||
// mImageFiles{op::getFilesOnDirectory(directoryPath, std::vector<std::string>{"jpg", "png"})},
|
||||
mCounter{0}
|
||||
{
|
||||
if (mImageFiles.empty())
|
||||
op::error("No images found on: " + directoryPath, __LINE__, __FUNCTION__, __FILE__);
|
||||
}
|
||||
|
||||
void initializationOnThread() {}
|
||||
|
||||
std::shared_ptr<std::vector<UserDatum>> workProducer()
|
||||
{
|
||||
try
|
||||
{
|
||||
// Close program when empty frame
|
||||
if (mImageFiles.size() <= mCounter)
|
||||
{
|
||||
op::log("Last frame read and added to queue. Closing program after it is processed.",
|
||||
op::Priority::High);
|
||||
// This funtion stops this worker, which will eventually stop the whole thread system once all the
|
||||
// frames have been processed
|
||||
this->stop();
|
||||
return nullptr;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Create new datum
|
||||
auto datumsPtr = std::make_shared<std::vector<UserDatum>>();
|
||||
datumsPtr->emplace_back();
|
||||
auto& datum = datumsPtr->at(0);
|
||||
|
||||
// Fill datum
|
||||
datum.cvInputData = cv::imread(mImageFiles.at(mCounter++));
|
||||
|
||||
// If empty frame -> return nullptr
|
||||
if (datum.cvInputData.empty())
|
||||
{
|
||||
op::log("Empty frame detected on path: " + mImageFiles.at(mCounter-1) + ". Closing program.",
|
||||
op::Priority::High);
|
||||
this->stop();
|
||||
datumsPtr = nullptr;
|
||||
}
|
||||
|
||||
return datumsPtr;
|
||||
}
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
this->stop();
|
||||
op::error(e.what(), __LINE__, __FUNCTION__, __FILE__);
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
const std::vector<std::string> mImageFiles;
|
||||
unsigned long long mCounter;
|
||||
};
|
||||
|
||||
// This worker will just invert the image
|
||||
class WUserPostProcessing : public op::Worker<std::shared_ptr<std::vector<UserDatum>>>
|
||||
{
|
||||
public:
|
||||
WUserPostProcessing()
|
||||
{
|
||||
// User's constructor here
|
||||
}
|
||||
|
||||
void initializationOnThread() {}
|
||||
|
||||
void work(std::shared_ptr<std::vector<UserDatum>>& datumsPtr)
|
||||
{
|
||||
// User's post-processing (after OpenPose processing & before OpenPose outputs) here
|
||||
// datum.cvOutputData: rendered frame with pose or heatmaps
|
||||
// datum.poseKeypoints: Array<float> with the estimated pose
|
||||
try
|
||||
{
|
||||
if (datumsPtr != nullptr && !datumsPtr->empty())
|
||||
for (auto& datum : *datumsPtr)
|
||||
cv::bitwise_not(datum.cvOutputData, datum.cvOutputData);
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
this->stop();
|
||||
op::error(e.what(), __LINE__, __FUNCTION__, __FILE__);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// This worker will just read and return all the jpg files in a directory
|
||||
class WUserOutput : public op::WorkerConsumer<std::shared_ptr<std::vector<UserDatum>>>
|
||||
{
|
||||
public:
|
||||
void initializationOnThread() {}
|
||||
|
||||
void workConsumer(const std::shared_ptr<std::vector<UserDatum>>& datumsPtr)
|
||||
{
|
||||
try
|
||||
{
|
||||
// User's displaying/saving/other processing here
|
||||
// datum.cvOutputData: rendered frame with pose or heatmaps
|
||||
// datum.poseKeypoints: Array<float> with the estimated pose
|
||||
if (datumsPtr != nullptr && !datumsPtr->empty())
|
||||
{
|
||||
// Show in command line the resulting pose keypoints for body, face and hands
|
||||
op::log("\nKeypoints:");
|
||||
// Accesing each element of the keypoints
|
||||
const auto& poseKeypoints = datumsPtr->at(0).poseKeypoints;
|
||||
op::log("Person pose keypoints:");
|
||||
for (auto person = 0 ; person < poseKeypoints.getSize(0) ; person++)
|
||||
{
|
||||
op::log("Person " + std::to_string(person) + " (x, y, score):");
|
||||
for (auto bodyPart = 0 ; bodyPart < poseKeypoints.getSize(1) ; bodyPart++)
|
||||
{
|
||||
std::string valueToPrint;
|
||||
for (auto xyscore = 0 ; xyscore < poseKeypoints.getSize(2) ; xyscore++)
|
||||
{
|
||||
valueToPrint += std::to_string( poseKeypoints[{person, bodyPart, xyscore}] ) + " ";
|
||||
}
|
||||
op::log(valueToPrint);
|
||||
}
|
||||
}
|
||||
op::log(" ");
|
||||
// Alternative: just getting std::string equivalent
|
||||
op::log("Face keypoints: " + datumsPtr->at(0).faceKeypoints.toString());
|
||||
op::log("Left hand keypoints: " + datumsPtr->at(0).handKeypoints[0].toString());
|
||||
op::log("Right hand keypoints: " + datumsPtr->at(0).handKeypoints[1].toString());
|
||||
// Heatmaps
|
||||
const auto& poseHeatMaps = datumsPtr->at(0).poseHeatMaps;
|
||||
if (!poseHeatMaps.empty())
|
||||
{
|
||||
op::log("Pose heatmaps size: [" + std::to_string(poseHeatMaps.getSize(0)) + ", "
|
||||
+ std::to_string(poseHeatMaps.getSize(1)) + ", "
|
||||
+ std::to_string(poseHeatMaps.getSize(2)) + "]");
|
||||
const auto& faceHeatMaps = datumsPtr->at(0).faceHeatMaps;
|
||||
op::log("Face heatmaps size: [" + std::to_string(faceHeatMaps.getSize(0)) + ", "
|
||||
+ std::to_string(faceHeatMaps.getSize(1)) + ", "
|
||||
+ std::to_string(faceHeatMaps.getSize(2)) + ", "
|
||||
+ std::to_string(faceHeatMaps.getSize(3)) + "]");
|
||||
const auto& handHeatMaps = datumsPtr->at(0).handHeatMaps;
|
||||
op::log("Left hand heatmaps size: [" + std::to_string(handHeatMaps[0].getSize(0)) + ", "
|
||||
+ std::to_string(handHeatMaps[0].getSize(1)) + ", "
|
||||
+ std::to_string(handHeatMaps[0].getSize(2)) + ", "
|
||||
+ std::to_string(handHeatMaps[0].getSize(3)) + "]");
|
||||
op::log("Right hand heatmaps size: [" + std::to_string(handHeatMaps[1].getSize(0)) + ", "
|
||||
+ std::to_string(handHeatMaps[1].getSize(1)) + ", "
|
||||
+ std::to_string(handHeatMaps[1].getSize(2)) + ", "
|
||||
+ std::to_string(handHeatMaps[1].getSize(3)) + "]");
|
||||
}
|
||||
|
||||
// Display rendered output image
|
||||
cv::imshow("User worker GUI", datumsPtr->at(0).cvOutputData);
|
||||
// Display image and sleeps at least 1 ms (it usually sleeps ~5-10 msec to display the image)
|
||||
const char key = (char)cv::waitKey(1);
|
||||
if (key == 27)
|
||||
this->stop();
|
||||
}
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
this->stop();
|
||||
op::error(e.what(), __LINE__, __FUNCTION__, __FILE__);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int openPoseTutorialWrapper2()
|
||||
{
|
||||
try
|
||||
{
|
||||
op::log("Starting OpenPose demo...", op::Priority::High);
|
||||
const auto timerBegin = std::chrono::high_resolution_clock::now();
|
||||
|
||||
// logging_level
|
||||
op::check(0 <= FLAGS_logging_level && FLAGS_logging_level <= 255, "Wrong logging_level value.",
|
||||
__LINE__, __FUNCTION__, __FILE__);
|
||||
op::ConfigureLog::setPriorityThreshold((op::Priority)FLAGS_logging_level);
|
||||
op::Profiler::setDefaultX(FLAGS_profile_speed);
|
||||
|
||||
// Applying user defined configuration - GFlags to program variables
|
||||
// outputSize
|
||||
const auto outputSize = op::flagsToPoint(FLAGS_output_resolution, "-1x-1");
|
||||
// netInputSize
|
||||
const auto netInputSize = op::flagsToPoint(FLAGS_net_resolution, "-1x368");
|
||||
// faceNetInputSize
|
||||
const auto faceNetInputSize = op::flagsToPoint(FLAGS_face_net_resolution, "368x368 (multiples of 16)");
|
||||
// handNetInputSize
|
||||
const auto handNetInputSize = op::flagsToPoint(FLAGS_hand_net_resolution, "368x368 (multiples of 16)");
|
||||
// poseModel
|
||||
const auto poseModel = op::flagsToPoseModel(FLAGS_model_pose);
|
||||
// JSON saving
|
||||
if (!FLAGS_write_keypoint.empty())
|
||||
op::log("Flag `write_keypoint` is deprecated and will eventually be removed."
|
||||
" Please, use `write_json` instead.", op::Priority::Max);
|
||||
// keypointScale
|
||||
const auto keypointScale = op::flagsToScaleMode(FLAGS_keypoint_scale);
|
||||
// heatmaps to add
|
||||
const auto heatMapTypes = op::flagsToHeatMaps(FLAGS_heatmaps_add_parts, FLAGS_heatmaps_add_bkg,
|
||||
FLAGS_heatmaps_add_PAFs);
|
||||
const auto heatMapScale = op::flagsToHeatMapScaleMode(FLAGS_heatmaps_scale);
|
||||
// >1 camera view?
|
||||
const auto multipleView = (FLAGS_3d || FLAGS_3d_views > 1);
|
||||
// Enabling Google Logging
|
||||
const bool enableGoogleLogging = true;
|
||||
// Logging
|
||||
op::log("", op::Priority::Low, __LINE__, __FUNCTION__, __FILE__);
|
||||
|
||||
// Initializing the user custom classes
|
||||
// Frames producer (e.g. video, webcam, ...)
|
||||
auto wUserInput = std::make_shared<WUserInput>(FLAGS_image_dir);
|
||||
// Processing
|
||||
auto wUserPostProcessing = std::make_shared<WUserPostProcessing>();
|
||||
// GUI (Display)
|
||||
auto wUserOutput = std::make_shared<WUserOutput>();
|
||||
|
||||
op::Wrapper<std::vector<UserDatum>> opWrapper;
|
||||
// Add custom input
|
||||
const auto workerInputOnNewThread = false;
|
||||
opWrapper.setWorker(op::WorkerType::Input, wUserInput, workerInputOnNewThread);
|
||||
// Add custom processing
|
||||
const auto workerProcessingOnNewThread = false;
|
||||
opWrapper.setWorker(op::WorkerType::PostProcessing, wUserPostProcessing, workerProcessingOnNewThread);
|
||||
// Add custom output
|
||||
const auto workerOutputOnNewThread = true;
|
||||
opWrapper.setWorker(op::WorkerType::Output, wUserOutput, workerOutputOnNewThread);
|
||||
// Configure OpenPose
|
||||
op::log("Configuring OpenPose wrapper...", op::Priority::Low, __LINE__, __FUNCTION__, __FILE__);
|
||||
const op::WrapperStructPose wrapperStructPose{
|
||||
!FLAGS_body_disable, netInputSize, outputSize, keypointScale, FLAGS_num_gpu, FLAGS_num_gpu_start,
|
||||
FLAGS_scale_number, (float)FLAGS_scale_gap, op::flagsToRenderMode(FLAGS_render_pose, multipleView),
|
||||
poseModel, !FLAGS_disable_blending, (float)FLAGS_alpha_pose, (float)FLAGS_alpha_heatmap,
|
||||
FLAGS_part_to_show, FLAGS_model_folder, heatMapTypes, heatMapScale, FLAGS_part_candidates,
|
||||
(float)FLAGS_render_threshold, FLAGS_number_people_max, enableGoogleLogging};
|
||||
// Face configuration (use op::WrapperStructFace{} to disable it)
|
||||
const op::WrapperStructFace wrapperStructFace{
|
||||
FLAGS_face, faceNetInputSize, op::flagsToRenderMode(FLAGS_face_render, multipleView, FLAGS_render_pose),
|
||||
(float)FLAGS_face_alpha_pose, (float)FLAGS_face_alpha_heatmap, (float)FLAGS_face_render_threshold};
|
||||
// Hand configuration (use op::WrapperStructHand{} to disable it)
|
||||
const op::WrapperStructHand wrapperStructHand{
|
||||
FLAGS_hand, handNetInputSize, FLAGS_hand_scale_number, (float)FLAGS_hand_scale_range, FLAGS_hand_tracking,
|
||||
op::flagsToRenderMode(FLAGS_hand_render, multipleView, FLAGS_render_pose), (float)FLAGS_hand_alpha_pose,
|
||||
(float)FLAGS_hand_alpha_heatmap, (float)FLAGS_hand_render_threshold};
|
||||
// Extra functionality configuration (use op::WrapperStructExtra{} to disable it)
|
||||
const op::WrapperStructExtra wrapperStructExtra{
|
||||
FLAGS_3d, FLAGS_3d_min_views, FLAGS_identification, FLAGS_tracking, FLAGS_ik_threads};
|
||||
// Consumer (comment or use default argument to disable any output)
|
||||
const auto displayMode = op::DisplayMode::NoDisplay;
|
||||
const bool guiVerbose = false;
|
||||
const bool fullScreen = false;
|
||||
const op::WrapperStructOutput wrapperStructOutput{
|
||||
displayMode, guiVerbose, fullScreen, FLAGS_write_keypoint,
|
||||
op::stringToDataFormat(FLAGS_write_keypoint_format), FLAGS_write_json, FLAGS_write_coco_json,
|
||||
FLAGS_write_coco_foot_json, FLAGS_write_images, FLAGS_write_images_format, FLAGS_write_video,
|
||||
FLAGS_camera_fps, FLAGS_write_heatmaps, FLAGS_write_heatmaps_format, FLAGS_write_video_adam,
|
||||
FLAGS_write_bvh, FLAGS_udp_host, FLAGS_udp_port};
|
||||
// Configure wrapper
|
||||
opWrapper.configure(wrapperStructPose, wrapperStructFace, wrapperStructHand, wrapperStructExtra,
|
||||
op::WrapperStructInput{}, wrapperStructOutput);
|
||||
// Set to single-thread (for sequential processing and/or debugging and/or reducing latency)
|
||||
if (FLAGS_disable_multi_thread)
|
||||
opWrapper.disableMultiThreading();
|
||||
|
||||
op::log("Starting thread(s)...", op::Priority::High);
|
||||
// Two different ways of running the program on multithread environment
|
||||
// Start, run & stop threads - it blocks this thread until all others have finished
|
||||
opWrapper.exec();
|
||||
|
||||
// Option b) Keeping this thread free in case you want to do something else meanwhile, e.g. profiling the GPU memory
|
||||
// // VERY IMPORTANT NOTE: if OpenCV is compiled with Qt support, this option will not work. Qt needs the main
|
||||
// // thread to plot visual results, so the final GUI (which uses OpenCV) would return an exception similar to:
|
||||
// // `QMetaMethod::invoke: Unable to invoke methods with return values in queued connections`
|
||||
// // Start threads
|
||||
// opWrapper.start();
|
||||
// // Profile used GPU memory
|
||||
// // 1: wait ~10sec so the memory has been totally loaded on GPU
|
||||
// // 2: profile the GPU memory
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds{1000});
|
||||
// op::log("Random task here...", op::Priority::High);
|
||||
// // Keep program alive while running threads
|
||||
// while (opWrapper.isRunning())
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds{33});
|
||||
// // Stop and join threads
|
||||
// op::log("Stopping thread(s)", op::Priority::High);
|
||||
// opWrapper.stop();
|
||||
|
||||
// Measuring total time
|
||||
const auto now = std::chrono::high_resolution_clock::now();
|
||||
const auto totalTimeSec = (double)std::chrono::duration_cast<std::chrono::nanoseconds>(now-timerBegin).count()
|
||||
* 1e-9;
|
||||
const auto message = "OpenPose demo successfully finished. Total time: "
|
||||
+ std::to_string(totalTimeSec) + " seconds.";
|
||||
op::log(message, op::Priority::High);
|
||||
|
||||
// Return successful message
|
||||
return 0;
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
op::error(e.what(), __LINE__, __FUNCTION__, __FILE__);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// Parsing command line flags
|
||||
gflags::ParseCommandLineFlags(&argc, &argv, true);
|
||||
|
||||
// Running openPoseTutorialWrapper2
|
||||
return openPoseTutorialWrapper2();
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
set(EXAMPLE_FILES
|
||||
1_body_from_image.cpp
|
||||
2_whole_body_from_image.cpp
|
||||
3_keypoints_from_image_configurable.cpp
|
||||
4_asynchronous_loop_custom_input_and_output.cpp
|
||||
5_asynchronous_loop_custom_output.cpp
|
||||
6_synchronous_custom_postprocessing.cpp
|
||||
7_synchronous_custom_input.cpp
|
||||
8_synchronous_custom_output.cpp
|
||||
9_synchronous_custom_all.cpp)
|
||||
|
||||
include(${CMAKE_SOURCE_DIR}/cmake/Utils.cmake)
|
||||
|
||||
foreach(EXAMPLE_FILE ${EXAMPLE_FILES})
|
||||
|
||||
get_filename_component(SOURCE_NAME ${EXAMPLE_FILE} NAME_WE)
|
||||
|
||||
if (UNIX OR APPLE)
|
||||
set(EXE_NAME "${SOURCE_NAME}.bin")
|
||||
elseif (WIN32)
|
||||
set(EXE_NAME "${SOURCE_NAME}")
|
||||
endif ()
|
||||
|
||||
message(STATUS "Adding Example ${EXE_NAME}")
|
||||
add_executable(${EXE_NAME} ${EXAMPLE_FILE})
|
||||
target_link_libraries(${EXE_NAME} openpose ${examples_3rdparty_libraries})
|
||||
|
||||
if (WIN32)
|
||||
set_property(TARGET ${EXE_NAME} PROPERTY FOLDER "Examples/Tutorial/C++ API")
|
||||
configure_file(${CMAKE_SOURCE_DIR}/cmake/OpenPose${VCXPROJ_FILE_GPU_MODE}.vcxproj.user
|
||||
${CMAKE_CURRENT_BINARY_DIR}/${EXE_NAME}.vcxproj.user @ONLY)
|
||||
# Properties->General->Output Directory
|
||||
set_property(TARGET ${EXE_NAME} PROPERTY RUNTIME_OUTPUT_DIRECTORY_RELEASE ${PROJECT_BINARY_DIR}/$(Platform)/$(Configuration))
|
||||
set_property(TARGET ${EXE_NAME} PROPERTY RUNTIME_OUTPUT_DIRECTORY_DEBUG ${PROJECT_BINARY_DIR}/$(Platform)/$(Configuration))
|
||||
endif (WIN32)
|
||||
|
||||
endforeach()
|
||||
@@ -0,0 +1,2 @@
|
||||
# C++ API Examples
|
||||
This folder provides examples to the basic OpenPose C++ API. The analogous Python API is exposed in [examples/tutorial_api_python/](../tutorial_api_python/).
|
||||
Reference in New Issue
Block a user