// ------------------------------------------------ OpenPose C++ Demo ------------------------------------------------

// This example summarizes all the functionality of the OpenPose library. It can...

// 1. Read a frames source (images, video, webcam, 3D stereo Flir cameras, etc.).

// 2. Extract and render body/hand/face/foot keypoint/heatmap/PAF of that image.

// 3. Save the results on disk.

// 4. Display the rendered pose.

// If the user wants to learn to use the OpenPose C++ library, we highly recommend to start with the examples in

// `examples/tutorial_api_cpp/`.

// Command-line user intraface

#include <openpose/flags.hpp>

// OpenPose dependencies

#include <openpose/headers.hpp>

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

// cameraSize

const auto cameraSize = op::flagsToPoint(FLAGS_camera_resolution, "-1x-1");

// 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

op::ProducerType producerType;

std::string producerString;

std::tie(producerType, producerString) = op::flagsToProducer(

FLAGS_image_dir, FLAGS_video, FLAGS_ip_camera, FLAGS_camera, FLAGS_flir_camera, 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;

// Configuring OpenPose

op::log("Configuring OpenPose...", op::Priority::High);

op::Wrapper opWrapper;

// 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, FLAGS_maximize_positives, FLAGS_fps_max,

enableGoogleLogging};

opWrapper.configure(wrapperStructPose);

// 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};

opWrapper.configure(wrapperStructFace);

// 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};

opWrapper.configure(wrapperStructHand);

// 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};

opWrapper.configure(wrapperStructExtra);

// Producer (use default to disable any input)

const op::WrapperStructInput wrapperStructInput{

producerType, producerString, FLAGS_frame_first, FLAGS_frame_step, FLAGS_frame_last,

FLAGS_process_real_time, FLAGS_frame_flip, FLAGS_frame_rotate, FLAGS_frames_repeat,

cameraSize, FLAGS_camera_parameter_path, FLAGS_frame_undistort, FLAGS_3d_views};

opWrapper.configure(wrapperStructInput);

// Output (comment or use default argument to disable any output)

const op::WrapperStructOutput wrapperStructOutput{

FLAGS_cli_verbose, FLAGS_write_keypoint, op::stringToDataFormat(FLAGS_write_keypoint_format),

FLAGS_write_json, FLAGS_write_coco_json, FLAGS_write_coco_foot_json, FLAGS_write_coco_json_variant,

FLAGS_write_images, FLAGS_write_images_format, FLAGS_write_video, FLAGS_write_video_fps,

FLAGS_write_heatmaps, FLAGS_write_heatmaps_format, FLAGS_write_video_3d, FLAGS_write_video_adam,

FLAGS_write_bvh, FLAGS_udp_host, FLAGS_udp_port};

opWrapper.configure(wrapperStructOutput);

// GUI (comment or use default argument to disable any visual output)

const op::WrapperStructGui wrapperStructGui{

op::flagsToDisplayMode(FLAGS_display, FLAGS_3d), !FLAGS_no_gui_verbose, FLAGS_fullscreen};

opWrapper.configure(wrapperStructGui);

// Set to single-thread (for sequential processing and/or debugging and/or reducing latency)

if (FLAGS_disable_multi_thread)

opWrapper.disableMultiThreading();

// Start, run, and stop processing - exec() blocks this thread until OpenPose wrapper has finished

op::log("Starting thread(s)...", op::Priority::High);

opWrapper.exec();

// 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)

{

return -1;

}

}

int main(int argc, char *argv[])

{

// Parsing command line flags

gflags::ParseCommandLineFlags(&argc, &argv, true);

// Running openPoseDemo

return openPoseDemo();

}