Chiebot-Mirror
/
opencv
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

added gpu HOG sample

Browse Source
pull/13383/head
Alexey Spizhevoy 15 years ago
parent 4568d702ff
commit 6c326eb4bb
4 changed files with 433 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      samples/CMakeLists.txt
  2. 59
      samples/gpu/CMakeLists.txt
  3. 373
      samples/gpu/gpu_hog.cpp
  4. BIN
      samples/gpu/road.png

1
samples/CMakeLists.txt
Unescape View File

@ -7,3 +7,4 @@ add_subdirectory(c)
add_subdirectory(cpp)
add_subdirectory(swig_python)
add_subdirectory(octave)
#add_subdirectory(gpu)

59
samples/gpu/CMakeLists.txt
Unescape View File

@ -0,0 +1,59 @@
if (BUILD_EXAMPLES)
project(gpu_samples)
include_directories(
"${CMAKE_SOURCE_DIR}/modules/core/include"
"${CMAKE_SOURCE_DIR}/modules/flann/include"
"${CMAKE_SOURCE_DIR}/modules/imgproc/include"
"${CMAKE_SOURCE_DIR}/modules/video/include"
"${CMAKE_SOURCE_DIR}/modules/highgui/include"
"${CMAKE_SOURCE_DIR}/modules/ml/include"
"${CMAKE_SOURCE_DIR}/modules/calib3d/include"
"${CMAKE_SOURCE_DIR}/modules/features2d/include"
"${CMAKE_SOURCE_DIR}/modules/objdetect/include"
"${CMAKE_SOURCE_DIR}/modules/legacy/include"
"${CMAKE_SOURCE_DIR}/modules/contrib/include"
"${CMAKE_SOURCE_DIR}/modules/gpu/include"
)
if(CMAKE_COMPILER_IS_GNUCXX)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-function")
endif()
# ---------------------------------------------
# Define executable targets
# ---------------------------------------------
MACRO(MY_DEFINE_EXAMPLE name srcs)
set(the_target "example_${name}")
add_executable(${the_target} ${srcs})
set_target_properties(${the_target} PROPERTIES
OUTPUT_NAME "${name}"
PROJECT_LABEL "(EXAMPLE) ${name}")
add_dependencies(${the_target} opencv_core opencv_flann opencv_imgproc opencv_highgui
opencv_ml opencv_video opencv_objdetect opencv_features2d
opencv_calib3d opencv_legacy opencv_contrib opencv_gpu)
target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} opencv_core
opencv_flann opencv_imgproc opencv_highgui opencv_ml opencv_video opencv_objdetect
opencv_features2d opencv_calib3d opencv_legacy opencv_contrib opencv_gpu)
if(WIN32)
install(TARGETS ${the_target}
RUNTIME DESTINATION "samples/gpu" COMPONENT main)
endif()
ENDMACRO(MY_DEFINE_EXAMPLE)
file(GLOB gpu_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
foreach(sample_filename ${gpu_samples})
get_filename_component(sample ${sample_filename} NAME_WE)
MY_DEFINE_EXAMPLE(${sample} ${sample_filename})
endforeach()
endif(BUILD_EXAMPLES)
if (NOT WIN32)
file(GLOB GPU_FILES *.c *.cpp *.jpg *.png *.data makefile.* build_all.sh *.dsp *.cmd )
install(FILES ${GPU_FILES}
DESTINATION share/opencv/samples/gpu
PERMISSIONS OWNER_READ GROUP_READ WORLD_READ)
endif ()

373
samples/gpu/gpu_hog.cpp
Unescape View File

@ -0,0 +1,373 @@
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <iomanip>
#include "opencv2/gpu/gpu.hpp"
#include "opencv2/highgui/highgui.hpp"
using namespace std;
using namespace cv;
/** Contains all properties of application (including those which can be
changed by user in runtime) */
class Settings
{
public:
/** Sets default values */
Settings();
/** Reads settings from command args */
static Settings Read(int argc, char** argv);
string src;
bool src_is_video;
bool make_gray;
bool resize_src;
double resize_src_scale;
double scale;
int nlevels;
int gr_threshold;
double hit_threshold;
int win_width;
};
/** Describes aplication logic */
class App
{
public:
/** Initializes application */
App(const Settings& s);
/** Runs demo using OpenCV highgui module for GUI building */
void RunOpencvGui();
/** Processes user keybord input */
void HandleKey(char key);
void HogWorkBegin();
void HogWorkEnd();
double HogWorkFps() const;
void WorkBegin();
void WorkEnd();
double WorkFps() const;
const string GetPerformanceSummary() const;
private:
App operator=(App&);
Settings settings;
bool running;
bool use_gpu;
bool make_gray;
double scale;
int gr_threshold;
int nlevels;
double hit_threshold;
int64 hog_work_begin;
double hog_work_fps;
int64 work_begin;
double work_fps;
};
int main(int argc, char** argv)
{
try
{
if (argc < 2)
{
cout << "Usage:\nsample_hog\n"
<< " -src <path_to_the_source>\n"
<< " [-src_is_video <true/false>] # says to interp. src as img or as video\n"
<< " [-make_gray <true/false>] # convert image to gray one or not\n"
<< " [-resize_src <true/false>] # do resize of the source image or not\n"
<< " [-resize_src_scale <double>] # preprocessing image scale factor\n"
<< " [-hit_threshold <double>] # classifying plane dist. threshold (0.0 usually)\n"
<< " [-scale <double>] # HOG window scale factor\n"
<< " [-nlevels <int>] # max number of HOG window scales\n"
<< " [-win_width <int>] # width of the window (48 or 64)\n"
<< " [-gr_threshold <int>] # merging similar rects constant\n";
return 1;
}
App app(Settings::Read(argc, argv));
app.RunOpencvGui();
}
catch (const Exception& e) { return cout << "Error: " << e.what() << endl, 1; }
catch (const exception& e) { return cout << "Error: " << e.what() << endl, 1; }
catch(...) { return cout << "Unknown exception" << endl, 1; }
return 0;
}
Settings::Settings()
{
src_is_video = false;
make_gray = false;
resize_src = true;
resize_src_scale = 1.5;
scale = 1.05;
nlevels = 13;
gr_threshold = 8;
hit_threshold = 1.4;
win_width = 48;
}
Settings Settings::Read(int argc, char** argv)
{
cout << "Parsing command args" << endl;
Settings settings;
for (int i = 1; i < argc - 1; i += 2)
{
string key = argv[i];
string val = argv[i + 1];
if (key == "-src") settings.src = val;
else if (key == "-src_is_video") settings.src_is_video = (val == "true");
else if (key == "-make_gray") settings.make_gray = (val == "true");
else if (key == "-resize_src") settings.resize_src = (val == "true");
else if (key == "-resize_src_scale") settings.resize_src_scale = atof(val.c_str());
else if (key == "-hit_threshold") settings.hit_threshold = atof(val.c_str());
else if (key == "-scale") settings.scale = atof(val.c_str());
else if (key == "-nlevels") settings.nlevels = atoi(val.c_str());
else if (key == "-win_width") settings.win_width = atoi(val.c_str());
else if (key == "-gr_threshold") settings.gr_threshold = atoi(val.c_str());
else throw exception((string("Unknown key: ") + key).c_str());
}
cout << "Command args are parsed\n";
return settings;
}
App::App(const Settings &s)
{
settings = s;
cout << "\nControls:\n"
<< "ESC - exit\n"
<< "m - change mode GPU <-> CPU\n"
<< "g - convert image to gray or not\n"
<< "1/q - increase/decrease HOG scale\n"
<< "2/w - increase/decrease levels count\n"
<< "3/e - increase/decrease HOG group threshold\n"
<< "4/r - increase/decrease hit threshold\n"
<< endl;
use_gpu = true;
make_gray = settings.make_gray;
scale = settings.scale;
gr_threshold = settings.gr_threshold;
nlevels = settings.nlevels;
hit_threshold = settings.hit_threshold;
if (settings.win_width != 64 && settings.win_width != 48)
settings.win_width = 64;
cout << endl << "Scale: " << scale << endl;
cout << "Group threshold: " << gr_threshold << endl;
cout << "Levels number: " << nlevels << endl;
cout << "Win width: " << settings.win_width << endl;
cout << "Hit threshold: " << hit_threshold << endl;
cout << endl;
}
void App::RunOpencvGui()
{
running = true;
Size win_width(settings.win_width, settings.win_width * 2); //(64, 128) or (48, 96)
vector<float> detector;
if (win_width == Size(64,128))
detector = cv::gpu::HOGDescriptor::getPeopleDetector_64x128();
else
detector = cv::gpu::HOGDescriptor::getPeopleDetector_48x96();
// GPU's HOG classifier
cv::gpu::HOGDescriptor gpu_hog(win_width);
gpu_hog.setSVMDetector(detector);
// CPU's HOG classifier
cv::HOGDescriptor cpu_hog(win_width, Size(16,16), Size(8,8), Size(8,8), 9, 1, -1, HOGDescriptor::L2Hys, 0.2, true, HOGDescriptor::DEFAULT_NLEVELS);
cpu_hog.setSVMDetector(detector);
// Make endless cycle from video (if src is video)
while (running)
{
VideoCapture vc;
Mat frame;
if (settings.src_is_video)
{
vc.open(settings.src.c_str());
if (!vc.isOpened())
throw exception(string("Can't open video file: " + settings.src).c_str());
vc >> frame;
}
else
frame = imread(settings.src);
Mat img_aux, img, img_to_show;
gpu::GpuMat gpu_img;
// Iterate over all frames
while (running && !frame.empty())
{
WorkBegin();
vector<Rect> found;
// Change format of the image (input must be 8UC3)
if (make_gray)
cvtColor(frame, img_aux, CV_BGR2GRAY);
else if (use_gpu)
cvtColor(frame, img_aux, CV_BGR2BGRA);
else
img_aux = frame;
// Resize image
if (settings.resize_src)
resize(img_aux, img, Size(int(frame.cols * settings.resize_src_scale), int(frame.rows * settings.resize_src_scale)));
else
img = img_aux;
img_to_show = img;
gpu_hog.nlevels = nlevels;
cpu_hog.nlevels = nlevels;
// Perform HOG classification
HogWorkBegin();
if (use_gpu)
{
gpu_img = img;
gpu_hog.detectMultiScale(gpu_img, found, hit_threshold, Size(8, 8), Size(0, 0), scale, gr_threshold);
}
else
cpu_hog.detectMultiScale(img, found, hit_threshold, Size(8, 8), Size(0, 0), scale, gr_threshold);
HogWorkEnd();
// Draw positive classified windows
for (size_t i = 0; i < found.size(); i++)
{
Rect r = found[i];
rectangle(img_to_show, r.tl(), r.br(), CV_RGB(0, 255, 0), 3);
}
WorkEnd();
// Show results
putText(img_to_show, GetPerformanceSummary(), Point(5, 25), FONT_HERSHEY_SIMPLEX, 1.0, Scalar(0, 0, 255), 2);
imshow("opencv_gpu_hog", img_to_show);
HandleKey((char)waitKey(1));
if (settings.src_is_video)
{
vc >> frame;
}
}
}
}
void App::HandleKey(char key)
{
switch (key)
{
case 27:
running = false;
break;
case 'm':
case 'M':
use_gpu = !use_gpu;
cout << "Switched to " << (use_gpu ? "CUDA" : "CPU") << " mode\n";
break;
case 'g':
case 'G':
make_gray = !make_gray;
cout << "Convert image to gray: " << (make_gray ? "YES" : "NO") << endl;
break;
case '1':
scale *= 1.05;
cout << "Scale: " << scale << endl;
break;
case 'q':
case 'Q':
scale /= 1.05;
cout << "Scale: " << scale << endl;
break;
case '2':
nlevels++;
cout << "Levels number: " << nlevels << endl;
break;
case 'w':
case 'W':
nlevels = max(nlevels - 1, 1);
cout << "Levels number: " << nlevels << endl;
break;
case '3':
gr_threshold++;
cout << "Group threshold: " << gr_threshold << endl;
break;
case 'e':
case 'E':
gr_threshold = max(0, gr_threshold - 1);
cout << "Group threshold: " << gr_threshold << endl;
break;
case '4':
hit_threshold+=0.25;
cout << "Hit threshold: " << hit_threshold << endl;
break;
case 'r':
case 'R':
hit_threshold = max(0.0, hit_threshold - 0.25);
cout << "Hit threshold: " << hit_threshold << endl;
break;
}
}
inline void App::HogWorkBegin() { hog_work_begin = getTickCount(); }
inline void App::HogWorkEnd()
{
int64 delta = getTickCount() - hog_work_begin;
double freq = getTickFrequency();
hog_work_fps = freq / delta;
}
inline double App::HogWorkFps() const { return hog_work_fps; }
inline void App::WorkBegin() { work_begin = getTickCount(); }
inline void App::WorkEnd()
{
int64 delta = getTickCount() - work_begin;
double freq = getTickFrequency();
work_fps = freq / delta;
}
inline double App::WorkFps() const { return work_fps; }
inline const string App::GetPerformanceSummary() const
{
stringstream ss;
ss << (use_gpu ? "GPU" : "CPU") << " HOG FPS: " << setiosflags(ios::left) << setprecision(4) <<
setw(7) << HogWorkFps() << " Total FPS: " << setprecision(4) << setw(7) << WorkFps();
return ss.str();
}

BIN
samples/gpu/road.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 675 KiB

Write Preview
Loading…
Cancel
Save