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

fixed all warnings

Browse Source
pull/3471/head
kallaballa 2 years ago
parent fdb26c873b
commit 854452c30d
11 changed files with 189 additions and 223 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
      modules/v4d/CMakeLists.txt
  2. 18
      modules/v4d/include/opencv2/v4d/util.hpp
  3. 250
      modules/v4d/include/opencv2/v4d/v4d.hpp
  4. 10
      modules/v4d/samples/beauty-demo.cpp
  5. 2
      modules/v4d/samples/display_image_fb.cpp
  6. 69
      modules/v4d/samples/font-demo.cpp
  7. 1
      modules/v4d/samples/font_with_gui.cpp
  8. 14
      modules/v4d/samples/many_cubes-demo.cpp
  9. 25
      modules/v4d/samples/shader-demo.cpp
  10. 1
      modules/v4d/src/detail/imguicontext.cpp
  11. 21
      modules/v4d/src/util.cpp

1
modules/v4d/CMakeLists.txt
Unescape View File

@ -261,6 +261,7 @@ if(NOT (TARGET ${the_module}))
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DOPENCV_V4D_USE_ES3=1")
endif()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-sign-promo")
target_compile_features(${the_module} PRIVATE cxx_std_20)
ocv_warnings_disable(CMAKE_CXX_FLAGS -Wdeprecated-enum-enum-conversion)

18
modules/v4d/include/opencv2/v4d/util.hpp
Unescape View File

@ -138,23 +138,7 @@ struct function_traits<R (T::*)(Args...) const> {
//https://stackoverflow.com/questions/281818/unmangling-the-result-of-stdtype-infoname
#ifdef __GNUG__
static std::string demangle(const char* name) {
int status = -4; // some arbitrary value to eliminate the compiler warning
std::unique_ptr<char, void(*)(void*)> res {
abi::__cxa_demangle(name, NULL, NULL, &status),
std::free
};
return (status==0) ? res.get() : name ;
}
#else
// does nothing if not g++
static std::string demangle(const char* name) {
return name;
}
#endif
CV_EXPORTS std::string demangle(const char* name);
template <const size_t _UniqueId, typename _Res, typename... _ArgTypes>
struct fun_ptr_helper

250
modules/v4d/include/opencv2/v4d/v4d.hpp
Unescape View File

@ -35,8 +35,6 @@
#include <memory>
#include <vector>
#include <type_traits>
#define UNW_LOCAL_ONLY
#include <libunwind.h>
#include <stdio.h>
#include <opencv2/core.hpp>
@ -70,10 +68,10 @@ enum AllocateFlags {
class Plan {
public:
virtual ~Plan() {};
virtual void gui(cv::Ptr<V4D> window) {};
virtual void setup(cv::Ptr<V4D> window) {};
virtual void gui(cv::Ptr<V4D> window) { CV_UNUSED(window); };
virtual void setup(cv::Ptr<V4D> window) { CV_UNUSED(window); };
virtual void infer(cv::Ptr<V4D> window) = 0;
virtual void teardown(cv::Ptr<V4D> window) {};
virtual void teardown(cv::Ptr<V4D> window) { CV_UNUSED(window); };
};
/*!
* Private namespace
@ -105,6 +103,49 @@ template<typename Tlamba> std::string lambda_ptr_hex(Tlamba&& l) {
return int_to_hex((size_t)Lambda::ptr(l));
}
static std::size_t index(const std::thread::id id)
{
static std::size_t nextindex = 0;
static std::mutex my_mutex;
static std::unordered_map<std::thread::id, std::size_t> ids;
std::lock_guard<std::mutex> lock(my_mutex);
auto iter = ids.find(id);
if(iter == ids.end())
return ids[id] = nextindex++;
return iter->second;
}
template<typename Tfn, typename Textra>
const string make_id(const string& name, Tfn&& fn, const Textra& extra) {
stringstream ss;
stringstream ssExtra;
ssExtra << extra;
if(ssExtra.str().empty()) {
ss << name << "(" << index(std::this_thread::get_id()) << "-" << detail::lambda_ptr_hex(std::forward<Tfn>(fn)) << ")";
}
else {
ss << name << "(" << index(std::this_thread::get_id()) << "-" << detail::lambda_ptr_hex(std::forward<Tfn>(fn)) << ")/" << ssExtra.str();
}
return ss.str();
}
template<typename Tfn>
const string make_id(const string& name, Tfn&& fn, const string& extra = "") {
return make_id<Tfn, std::string>(name, fn, extra);
}
template<typename Tfn, typename Textra>
void print_id(const string& name, Tfn&& fn, const Textra& extra) {
cerr << make_id<Tfn, Textra>(name, fn, extra) << endl;
}
template<typename Tfn>
void print_id(const string& name, Tfn&& fn, const string& extra = "") {
cerr << make_id<Tfn, std::string>(name, fn, extra) << endl;
}
}
using namespace cv::v4d::detail;
@ -271,78 +312,16 @@ public:
}
}
// template<typename Tfn, typename Tfb = cv::UMat&, typename ...Args>
// void add_transaction(const string& context, Tfn&& fn, cv::UMat&& fb, Args&& ...args) {
// auto it = transactions_.find(context);
// if(it == transactions_.end()) {
// transactions_.insert({context, make_transaction<Tfn&&, Tfb&&>(std::forward<Tfn>(fn), std::forward<Tfb>(fb), std::forward<Args>(args)...)});
// }
// }
//
// template<typename Tfn, typename Tfb = const cv::UMat&&, typename ...Args>
// void add_transaction(const string& context, Tfn&& fn, const cv::UMat&& fb, Args&& ...args) {
// auto it = transactions_.find(context);
// if(it == transactions_.end()) {
// transactions_.insert({context, make_transaction<Tfn&&, Tfb&&>(std::forward<Tfn>(fn), std::forward<Tfb>(fb), std::forward<Args>(args)...)});
// }
// }
std::size_t index(const std::thread::id id)
{
static std::size_t nextindex = 0;
static std::mutex my_mutex;
static std::unordered_map<std::thread::id, std::size_t> ids;
std::lock_guard<std::mutex> lock(my_mutex);
auto iter = ids.find(id);
if(iter == ids.end())
return ids[id] = nextindex++;
return iter->second;
}
template<typename Tfn, typename Textra>
const string make_id(const string& name, Tfn&& fn, const Textra& extra) {
stringstream ss;
stringstream ssExtra;
ssExtra << extra;
if(ssExtra.str().empty()) {
ss << name << "(" << index(std::this_thread::get_id()) << "-" << detail::lambda_ptr_hex(std::forward<Tfn>(fn)) << ")";
}
else {
ss << name << "(" << index(std::this_thread::get_id()) << "-" << detail::lambda_ptr_hex(std::forward<Tfn>(fn)) << ")/" << ssExtra.str();
}
return ss.str();
}
template<typename Tfn>
const string make_id(const string& name, Tfn&& fn, const string& extra = "") {
return make_id<Tfn, std::string>(name, fn, extra);
}
template<typename Tfn, typename Textra>
void print_id(const string& name, Tfn&& fn, const Textra& extra) {
cerr << make_id<Tfn, Textra>(name, fn, extra) << endl;
}
template<typename Tfn>
void print_id(const string& name, Tfn&& fn, const string& extra = "") {
cerr << make_id<Tfn, std::string>(name, fn, extra) << endl;
}
template <typename Tfn, typename ... Args>
typename std::enable_if<std::is_invocable_v<Tfn, Args...>, void>::type
gl(Tfn fn, Args&& ... args) {
CV_Assert(detail::is_stateless_lambda<std::remove_cv_t<std::remove_reference_t<decltype(fn)>>>::value);
const string id = make_id("gl", fn, -1);
TimeTracker::getInstance()->execute(id, [this, fn, id, &args...](){
emit_access<std::true_type, cv::UMat, Args...>(id, true, &fbCtx()->fb());
(emit_access<std::true_type, std::remove_reference_t<Args>, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
emit_access<std::true_type, cv::UMat, Args...>(id, false, &fbCtx()->fb());
std::function functor(fn);
add_transaction(glCtx(-1), id, std::forward<decltype(functor)>(fn), std::forward<Args>(args)...);
});
emit_access<std::true_type, cv::UMat, Args...>(id, true, &fbCtx()->fb());
(emit_access<std::true_type, std::remove_reference_t<Args>, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
emit_access<std::true_type, cv::UMat, Args...>(id, false, &fbCtx()->fb());
std::function functor(fn);
add_transaction(glCtx(-1), id, std::forward<decltype(functor)>(fn), std::forward<Args>(args)...);
}
template <typename Tfn, typename ... Args>
@ -350,13 +329,11 @@ public:
CV_Assert(detail::is_stateless_lambda<std::remove_cv_t<std::remove_reference_t<decltype(fn)>>>::value);
const string id = make_id("gl", fn, idx);
TimeTracker::getInstance()->execute(id, [this, fn, idx, id, &args...](){
emit_access<std::true_type, cv::UMat, Args...>(id, true, &fbCtx()->fb());
(emit_access<std::true_type, std::remove_reference_t<Args>, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
emit_access<std::true_type, cv::UMat, Args...>(id, false, &fbCtx()->fb());
std::function<void((const int32_t&,Args...))> functor(fn);
add_transaction<decltype(functor),const int32_t&>(fbCtx(),id, std::forward<decltype(functor)>(functor), glCtx(idx)->getIndex(), std::forward<Args>(args)...);
});
emit_access<std::true_type, cv::UMat, Args...>(id, true, &fbCtx()->fb());
(emit_access<std::true_type, std::remove_reference_t<Args>, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
emit_access<std::true_type, cv::UMat, Args...>(id, false, &fbCtx()->fb());
std::function<void((const int32_t&,Args...))> functor(fn);
add_transaction<decltype(functor),const int32_t&>(fbCtx(),id, std::forward<decltype(functor)>(functor), glCtx(idx)->getIndex(), std::forward<Args>(args)...);
}
template <typename Tfn>
@ -364,11 +341,9 @@ public:
CV_Assert(detail::is_stateless_lambda<std::remove_cv_t<std::remove_reference_t<decltype(fn)>>>::value);
const string id = make_id("branch", fn);
TimeTracker::getInstance()->execute(id, [this, fn, id](){
std::function functor = fn;
emit_access<std::true_type, decltype(fn)>(id, true, &fn);
add_transaction(singleCtx(), id, functor);
});
std::function functor = fn;
emit_access<std::true_type, decltype(fn)>(id, true, &fn);
add_transaction(singleCtx(), id, functor);
}
template <typename Tfn, typename ... Args>
@ -376,11 +351,9 @@ public:
CV_Assert(detail::is_stateless_lambda<std::remove_cv_t<std::remove_reference_t<decltype(fn)>>>::value);
const string id = make_id("branch", fn);
TimeTracker::getInstance()->execute(id, [this, fn, id, &args...](){
(emit_access<std::true_type, std::remove_reference_t<Args>, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
std::function functor = fn;
add_transaction(singleCtx(), id, functor, std::forward<Args>(args)...);
});
(emit_access<std::true_type, std::remove_reference_t<Args>, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
std::function functor = fn;
add_transaction(singleCtx(), id, functor, std::forward<Args>(args)...);
}
template <typename Tfn>
@ -388,11 +361,9 @@ public:
CV_Assert(detail::is_stateless_lambda<std::remove_cv_t<std::remove_reference_t<decltype(fn)>>>::value);
const string id = make_id("endbranch", fn);
TimeTracker::getInstance()->execute(id, [this, fn, id] {
std::function functor = fn;
emit_access<std::true_type, decltype(fn)>(id, true, &fn);
add_transaction(singleCtx(), id, functor);
});
std::function functor = fn;
emit_access<std::true_type, decltype(fn)>(id, true, &fn);
add_transaction(singleCtx(), id, functor);
}
template <typename Tfn, typename ... Args>
@ -400,29 +371,24 @@ public:
CV_Assert(detail::is_stateless_lambda<std::remove_cv_t<std::remove_reference_t<decltype(fn)>>>::value);
const string id = make_id("endbranch", fn);
TimeTracker::getInstance()->execute(id, [this, fn, id, &args...](){
(emit_access<std::true_type, std::remove_reference_t<Args>, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
std::function functor = fn;
add_transaction(singleCtx(), id, functor, std::forward<Args>(args)...);
});
(emit_access<std::true_type, std::remove_reference_t<Args>, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
std::function functor = fn;
add_transaction(singleCtx(), id, functor, std::forward<Args>(args)...);
}
template <typename Tfn, typename ... Args>
void fb(Tfn fn, Args&& ... args) {
CV_Assert(detail::is_stateless_lambda<std::remove_cv_t<std::remove_reference_t<decltype(fn)>>>::value);
const string id = make_id("fb", fn);
TimeTracker::getInstance()->execute(id, [this, fn, id, &args...]{
using Tfb = std::add_lvalue_reference_t<typename std::tuple_element<0, typename function_traits<Tfn>::argument_types>::type>;
using Tfbbase = typename std::remove_cv<Tfb>::type;
using Tfbconst = std::add_const_t<Tfbbase>;
static_assert((std::is_same<Tfb, cv::UMat&>::value || std::is_same<Tfb, const cv::UMat&>::value) || !"The first argument must be eiter of type 'cv::UMat&' or 'const cv::UMat&'");
emit_access<std::true_type, cv::UMat, Tfb, Args...>(id, true, &fbCtx()->fb());
(emit_access<std::true_type, std::remove_reference_t<Args>, Tfb, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
emit_access<static_not<typename std::is_const<Tfbbase>::type>, cv::UMat, Tfb, Args...>(id, false, &fbCtx()->fb());
std::function<void((Tfb,Args...))> functor(fn);
add_transaction<decltype(functor),Tfb>(fbCtx(),id, std::forward<decltype(functor)>(functor), fbCtx()->fb(), std::forward<Args>(args)...);
});
using Tfb = std::add_lvalue_reference_t<typename std::tuple_element<0, typename function_traits<Tfn>::argument_types>::type>;
using Tfbbase = typename std::remove_cv<Tfb>::type;
static_assert((std::is_same<Tfb, cv::UMat&>::value || std::is_same<Tfb, const cv::UMat&>::value) || !"The first argument must be eiter of type 'cv::UMat&' or 'const cv::UMat&'");
emit_access<std::true_type, cv::UMat, Tfb, Args...>(id, true, &fbCtx()->fb());
(emit_access<std::true_type, std::remove_reference_t<Args>, Tfb, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
emit_access<static_not<typename std::is_const<Tfbbase>::type>, cv::UMat, Tfb, Args...>(id, false, &fbCtx()->fb());
std::function<void((Tfb,Args...))> functor(fn);
add_transaction<decltype(functor),Tfb>(fbCtx(),id, std::forward<decltype(functor)>(functor), fbCtx()->fb(), std::forward<Args>(args)...);
}
void capture(cv::UMat& frame) {
@ -449,15 +415,13 @@ public:
void capture(Tfn fn, Args&& ... args) {
CV_Assert(detail::is_stateless_lambda<std::remove_cv_t<std::remove_reference_t<decltype(fn)>>>::value);
const string id = make_id("capture", fn);
TimeTracker::getInstance()->execute(id, [this, fn, id, &args...]{
using Tfb = std::add_lvalue_reference_t<typename std::tuple_element<0, typename function_traits<Tfn>::argument_types>::type>;
static_assert((std::is_same<Tfb,const cv::UMat&>::value) || !"The first argument must be of type 'const cv::UMat&'");
emit_access<std::true_type, cv::UMat, Tfb, Args...>(id, true, &sourceCtx()->sourceBuffer());
(emit_access<std::true_type, std::remove_reference_t<Args>, Tfb, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
std::function<void((Tfb,Args...))> functor(fn);
add_transaction<decltype(functor),Tfb>(std::dynamic_pointer_cast<V4DContext>(sourceCtx()),id, std::forward<decltype(functor)>(functor), sourceCtx()->sourceBuffer(), std::forward<Args>(args)...);
});
using Tfb = std::add_lvalue_reference_t<typename std::tuple_element<0, typename function_traits<Tfn>::argument_types>::type>;
static_assert((std::is_same<Tfb,const cv::UMat&>::value) || !"The first argument must be of type 'const cv::UMat&'");
emit_access<std::true_type, cv::UMat, Tfb, Args...>(id, true, &sourceCtx()->sourceBuffer());
(emit_access<std::true_type, std::remove_reference_t<Args>, Tfb, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
std::function<void((Tfb,Args...))> functor(fn);
add_transaction<decltype(functor),Tfb>(std::dynamic_pointer_cast<V4DContext>(sourceCtx()),id, std::forward<decltype(functor)>(functor), sourceCtx()->sourceBuffer(), std::forward<Args>(args)...);
}
void write() {
@ -482,51 +446,43 @@ public:
void write(Tfn fn, Args&& ... args) {
CV_Assert(detail::is_stateless_lambda<std::remove_cv_t<std::remove_reference_t<decltype(fn)>>>::value);
const string id = make_id("write", fn);
TimeTracker::getInstance()->execute(id, [this, fn, id, &args...]{
using Tfb = std::add_lvalue_reference_t<typename std::tuple_element<0, typename function_traits<Tfn>::argument_types>::type>;
static_assert((std::is_same<Tfb,cv::UMat&>::value) || !"The first argument must be of type 'cv::UMat&'");
emit_access<std::true_type, cv::UMat, Tfb, Args...>(id, true, &sinkCtx()->sinkBuffer());
(emit_access<std::true_type, std::remove_reference_t<Args>, Tfb, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
emit_access<std::true_type, cv::UMat, Tfb, Args...>(id, false, &sinkCtx()->sinkBuffer());
std::function<void((Tfb,Args...))> functor(fn);
add_transaction<decltype(functor),Tfb>(std::dynamic_pointer_cast<V4DContext>(sinkCtx()),id, std::forward<decltype(functor)>(functor), sinkCtx()->sinkBuffer(), std::forward<Args>(args)...);
});
using Tfb = std::add_lvalue_reference_t<typename std::tuple_element<0, typename function_traits<Tfn>::argument_types>::type>;
static_assert((std::is_same<Tfb,cv::UMat&>::value) || !"The first argument must be of type 'cv::UMat&'");
emit_access<std::true_type, cv::UMat, Tfb, Args...>(id, true, &sinkCtx()->sinkBuffer());
(emit_access<std::true_type, std::remove_reference_t<Args>, Tfb, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
emit_access<std::true_type, cv::UMat, Tfb, Args...>(id, false, &sinkCtx()->sinkBuffer());
std::function<void((Tfb,Args...))> functor(fn);
add_transaction<decltype(functor),Tfb>(std::dynamic_pointer_cast<V4DContext>(sinkCtx()),id, std::forward<decltype(functor)>(functor), sinkCtx()->sinkBuffer(), std::forward<Args>(args)...);
}
template <typename Tfn, typename ... Args>
void nvg(Tfn fn, Args&&... args) {
CV_Assert(detail::is_stateless_lambda<std::remove_cv_t<std::remove_reference_t<decltype(fn)>>>::value);
const string id = make_id("nvg", fn);
TimeTracker::getInstance()->execute(id, [this, fn, id, &args...](){
emit_access<std::true_type, cv::UMat, Args...>(id, true, &fbCtx()->fb());
(emit_access<std::true_type, std::remove_reference_t<Args>, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
emit_access<std::true_type, cv::UMat, Args...>(id, false, &fbCtx()->fb());
std::function functor(fn);
add_transaction<decltype(functor)>(nvgCtx(), id, std::forward<decltype(functor)>(fn), std::forward<Args>(args)...);
});
emit_access<std::true_type, cv::UMat, Args...>(id, true, &fbCtx()->fb());
(emit_access<std::true_type, std::remove_reference_t<Args>, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
emit_access<std::true_type, cv::UMat, Args...>(id, false, &fbCtx()->fb());
std::function functor(fn);
add_transaction<decltype(functor)>(nvgCtx(), id, std::forward<decltype(functor)>(fn), std::forward<Args>(args)...);
}
template <typename Tfn, typename ... Args>
void single(Tfn fn, Args&&... args) {
CV_Assert(detail::is_stateless_lambda<std::remove_cv_t<std::remove_reference_t<decltype(fn)>>>::value);
const string id = make_id("single", fn);
TimeTracker::getInstance()->execute(id, [this, fn, id, &args...](){
(emit_access<std::true_type, std::remove_reference_t<Args>, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
std::function functor(fn);
add_transaction<decltype(functor)>(singleCtx(), id, std::forward<decltype(functor)>(fn), std::forward<Args>(args)...);
});
(emit_access<std::true_type, std::remove_reference_t<Args>, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
std::function functor(fn);
add_transaction<decltype(functor)>(singleCtx(), id, std::forward<decltype(functor)>(fn), std::forward<Args>(args)...);
}
template <typename Tfn, typename ... Args>
void parallel(Tfn fn, Args&&... args) {
CV_Assert(detail::is_stateless_lambda<std::remove_cv_t<std::remove_reference_t<decltype(fn)>>>::value);
const string id = make_id("parallel", fn);
TimeTracker::getInstance()->execute(id, [this, fn, id, &args...](){
(emit_access<std::true_type, std::remove_reference_t<Args>, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
std::function functor(fn);
add_transaction<decltype(functor)>(parallelCtx(), id, std::forward<decltype(functor)>(fn), std::forward<Args>(args)...);
});
(emit_access<std::true_type, std::remove_reference_t<Args>, Args...>(id, std::is_const_v<std::remove_reference_t<Args>>, &args),...);
std::function functor(fn);
add_transaction<decltype(functor)>(parallelCtx(), id, std::forward<decltype(functor)>(fn), std::forward<Args>(args)...);
}
template<typename Tfn, typename ... Args>

10
modules/v4d/samples/beauty-demo.cpp
Unescape View File

@ -220,25 +220,25 @@ public:
}
void gui(cv::Ptr<V4D> window) override {
window->imgui([](cv::Ptr<V4D> window, ImGuiContext* ctx, Params& params){
window->imgui([](cv::Ptr<V4D> win, ImGuiContext* ctx, Params& params){
using namespace ImGui;
SetCurrentContext(ctx);
Begin("Effect");
Text("Display");
Checkbox("Side by side", &params.sideBySide_);
if(Checkbox("Stetch", &params.stretch_)) {
window->setStretching(true);
win->setStretching(true);
} else
window->setStretching(false);
win->setStretching(false);
#ifndef __EMSCRIPTEN__
if(Button("Fullscreen")) {
window->setFullscreen(!window->isFullscreen());
win->setFullscreen(!win->isFullscreen());
};
#endif
if(Button("Offscreen")) {
window->setVisible(!window->isVisible());
win->setVisible(!win->isVisible());
};
Text("Face Skin");

2
modules/v4d/samples/display_image_fb.cpp
Unescape View File

@ -8,7 +8,7 @@ class DisplayImageFB : public Plan {
UMat image_;
UMat converted_;
public:
void setup(cv::Ptr<V4D> win) {
void setup(cv::Ptr<V4D> win) override {
win->parallel([](cv::UMat& image, cv::UMat& converted, const cv::Size& sz){
//Loads an image as a UMat (just in case we have hardware acceleration available)
#ifdef __EMSCRIPTEN__

69
modules/v4d/samples/font-demo.cpp
Unescape View File

@ -49,11 +49,12 @@ class FontDemoPlan : public Plan {
float fontSize_ = 40.0f;
cv::Scalar_<float> textColor_ = INITIAL_COLOR / 255.0;
float warpRatio_ = 1.0f/3.0f;
bool updateStars_ = true;
bool updatePerspective_ = true;
} params_;
//the text to display
vector<string> lines_;
bool updateStars_ = true;
bool updatePerspective_ = true;
//BGRA
cv::UMat stars_, warped_, frame_;
@ -72,32 +73,34 @@ class FontDemoPlan : public Plan {
int32_t translateY_;
public:
void gui(cv::Ptr<V4D> window) override {
window->imgui([this](cv::Ptr<V4D> window, ImGuiContext* ctx){
using namespace ImGui;
window->imgui([](cv::Ptr<V4D> win, ImGuiContext* ctx, Params& params){
CV_UNUSED(win);
using namespace ImGui;
SetCurrentContext(ctx);
Begin("Effect");
Text("Text Crawl");
SliderFloat("Font Size", &params_.fontSize_, 1.0f, 100.0f);
if(SliderFloat("Warp Ratio", &params_.warpRatio_, 0.1f, 1.0f))
updatePerspective_ = true;
ColorPicker4("Text Color", params_.textColor_.val);
SliderFloat("Font Size", &params.fontSize_, 1.0f, 100.0f);
if(SliderFloat("Warp Ratio", &params.warpRatio_, 0.1f, 1.0f))
params.updatePerspective_ = true;
ColorPicker4("Text Color", params.textColor_.val);
Text("Stars");
if(SliderFloat("Min Star Size", &params_.minStarSize_, 0.5f, 1.0f))
updateStars_ = true;
if(SliderFloat("Max Star Size", &params_.maxStarSize_, 1.0f, 10.0f))
updateStars_ = true;
if(SliderInt("Min Star Count", &params_.minStarCount_, 1, 1000))
updateStars_ = true;
if(SliderInt("Max Star Count", &params_.maxStarCount_, 1000, 5000))
updateStars_ = true;
if(SliderFloat("Min Star Alpha", &params_.starAlpha_, 0.2f, 1.0f))
updateStars_ = true;
if(SliderFloat("Min Star Size", &params.minStarSize_, 0.5f, 1.0f))
params.updateStars_ = true;
if(SliderFloat("Max Star Size", &params.maxStarSize_, 1.0f, 10.0f))
params.updateStars_ = true;
if(SliderInt("Min Star Count", &params.minStarCount_, 1, 1000))
params.updateStars_ = true;
if(SliderInt("Max Star Count", &params.maxStarCount_, 1000, 5000))
params.updateStars_ = true;
if(SliderFloat("Min Star Alpha", &params.starAlpha_, 0.2f, 1.0f))
params.updateStars_ = true;
End();
});
}, params_);
}
void setup(cv::Ptr<V4D> window) override {
CV_UNUSED(window);
//The text to display
string txt = cv::getBuildInformation();
//Save the text to a vector
@ -114,7 +117,7 @@ public:
auto always = []() { return true; };
auto isTrue = [](const bool& b) { return b; };
window->branch(isTrue, updateStars_);
window->branch(isTrue, params_.updateStars_);
{
window->nvg([](const cv::Size& sz, cv::RNG& rng, const Params& params) {
using namespace cv::v4d::nvg;
@ -136,9 +139,9 @@ public:
frameBuffer.copyTo(f);
}, stars_);
}
window->endbranch(isTrue, updateStars_);
window->endbranch(isTrue, params_.updateStars_);
window->branch(isTrue, updatePerspective_);
window->branch(isTrue, params_.updatePerspective_);
{
window->parallel([](cv::Mat& tm, const Params& params){
//Derive the transformation matrix tm for the pseudo 3D effect from quad1 and quad2.
@ -150,7 +153,7 @@ public:
tm = cv::getPerspectiveTransform(quad1, quad2);
}, tm_, params_);
}
window->endbranch(isTrue, updatePerspective_);
window->endbranch(isTrue, params_.updatePerspective_);
window->branch(always);
{
@ -175,15 +178,19 @@ public:
}
}, window->fbSize(), translateY_, cnt_, y_, textHeight_, lines_, params_);
window->fb([](cv::UMat& framebuffer, cv::UMat& w, cv::UMat& s, cv::Mat& t, cv::UMat& f) {
window->fb([](cv::UMat& framebuffer, cv::UMat& w, cv::UMat& s, cv::Mat& t) {
//Pseudo 3D text effect.
cv::warpPerspective(framebuffer, w, t, framebuffer.size(), cv::INTER_LINEAR, cv::BORDER_CONSTANT, cv::Scalar());
//Combine layers
cv::add(s, w, framebuffer);
framebuffer.copyTo(f);
}, warped_, stars_, tm_, frame_);
}, warped_, stars_, tm_);
window->write();
window->parallel([](const int32_t& translateY, const int32_t& textHeight, uint32_t& cnt, Params& params) {
params.updatePerspective_ = false;
params.updateStars_ = false;
window->parallel([](const int32_t& translateY, const int32_t& textHeight, uint32_t& cnt) {
if(-translateY > textHeight) {
//reset the scroll once the text is out of the picture
cnt = 0;
@ -192,13 +199,7 @@ public:
//Wrap the cnt around if it becomes to big.
if(cnt > std::numeric_limits<uint32_t>().max() / 2.0)
cnt = 0;
}, translateY_, textHeight_, cnt_);
window->write([](cv::UMat& outputFrame, const cv::UMat& f, bool& updatePerspective, bool& updateStars){
f.copyTo(outputFrame);
updatePerspective = false;
updateStars = false;
}, frame_, updatePerspective_, updateStars_);
}, translateY_, textHeight_, cnt_, params_);
}
window->endbranch(always);
}

1
modules/v4d/samples/font_with_gui.cpp
Unescape View File

@ -15,6 +15,7 @@ class FontWithGuiPlan: public Plan {
public:
void gui(Ptr<V4D> window) override {
window->imgui([](Ptr<V4D> win, ImGuiContext* ctx, Params& params) {
CV_UNUSED(win);
using namespace ImGui;
SetCurrentContext(ctx);
Begin("Settings");

14
modules/v4d/samples/many_cubes-demo.cpp
Unescape View File

@ -229,7 +229,7 @@ class ManyCubesDemoPlan : public Plan {
}
#endif
public:
void setup(cv::Ptr<V4D> window) {
void setup(cv::Ptr<V4D> window) override {
sz_ = window->fbSize();
for(size_t i = 0; i < NUMBER_OF_CUBES; ++i) {
window->gl(i, [](const size_t& ctxIdx, cv::Size& sz, GLuint& v, GLuint& sp, GLuint& ut){
@ -238,7 +238,7 @@ public:
}, sz_, vao[i], shaderProgram[i], uniformTransform[i]);
}
}
void infer(cv::Ptr<V4D> window) {
void infer(cv::Ptr<V4D> window) override {
window->gl([](){
//Clear the background
glClearColor(0.2, 0.24, 0.4, 1);
@ -248,9 +248,10 @@ public:
//Render using multiple OpenGL contexts
for(size_t i = 0; i < NUMBER_OF_CUBES; ++i) {
window->gl(i, [](const int32_t& ctxIdx, GLuint& v, GLuint& sp, GLuint& ut){
double pos = (((double(ctxIdx) / NUMBER_OF_CUBES) * 2.0) - 1) + (1.0 / NUMBER_OF_CUBES);
double x = sin((double(ctxIdx) / NUMBER_OF_CUBES) * 2 * M_PI) / 1.5;
double y = cos((double(ctxIdx) / NUMBER_OF_CUBES) * 2 * M_PI) / 1.5;
double angle = sin((double(ctxIdx) / NUMBER_OF_CUBES) * 2 * M_PI);
render_scene(pos, pos, angle, v, sp, ut);
render_scene(x, y, angle, v, sp, ut);
}, vao[i], shaderProgram[i], uniformTransform[i]);
}
@ -268,7 +269,8 @@ public:
}
};
int main() {
int main(int argc, char** argv) {
CV_UNUSED(argc);
cv::Ptr<V4D> window = V4D::make(WIDTH, HEIGHT, "Many Cubes Demo", IMGUI, OFFSCREEN);
#ifndef __EMSCRIPTEN__
@ -276,7 +278,7 @@ int main() {
auto sink = makeWriterSink(window, OUTPUT_FILENAME, FPS, cv::Size(WIDTH, HEIGHT));
window->setSink(sink);
#endif
window->run<ManyCubesDemoPlan>(0);
window->run<ManyCubesDemoPlan>(atoi(argv[1]));
return 0;
}

25
modules/v4d/samples/shader-demo.cpp
Unescape View File

@ -258,29 +258,30 @@ class ShaderDemoPlan : public Plan {
}
public:
void gui(cv::Ptr<V4D> window) override {
window->imgui([this](cv::Ptr<V4D> window, ImGuiContext* ctx) {
window->imgui([](cv::Ptr<V4D> win, ImGuiContext* ctx, Params& params) {
CV_UNUSED(win);
using namespace ImGui;
SetCurrentContext(ctx);
Begin("Fractal");
Text("Navigation");
SliderInt("Iterations", &params_.maxIterations_, 3, 50000);
if(SliderFloat("X", &params_.centerX_, -1.0f, 1.0f))
params_.manualNavigation_ = true;
SliderInt("Iterations", &params.maxIterations_, 3, 50000);
if(SliderFloat("X", &params.centerX_, -1.0f, 1.0f))
params.manualNavigation_ = true;
if(SliderFloat("Y", &params_.centerY_, -1.0f, 1.0f))
params_.manualNavigation_ = true;
if(SliderFloat("Y", &params.centerY_, -1.0f, 1.0f))
params.manualNavigation_ = true;
if(SliderFloat("Zoom", &params_.zoomFactor_, 1.0f, 100.0f))
params_.manualNavigation_ = true;
if(SliderFloat("Zoom", &params.zoomFactor_, 1.0f, 100.0f))
params.manualNavigation_ = true;
#ifndef __EMSCRIPTEN__
Text("Glow");
SliderInt("Kernel Size", &params_.glowKernelSize_, 1, 127);
SliderInt("Kernel Size", &params.glowKernelSize_, 1, 127);
#endif
Text("Color");
ColorPicker4("Color", params_.baseColorVal_);
SliderInt("Contrast boost", &params_.contrastBoost_, 1, 255);
ColorPicker4("Color", params.baseColorVal_);
SliderInt("Contrast boost", &params.contrastBoost_, 1, 255);
End();
});
}, params_);
}
void setup(cv::Ptr<V4D> window) override {

1
modules/v4d/src/detail/imguicontext.cpp
Unescape View File

@ -73,7 +73,6 @@ void ImGuiContextImpl::render(bool showFPS) {
ImGui::SetNextWindowPos(pos, ImGuiCond_Once);
ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.0f, 0.0f, 0.0f, 0.5f));
ImGui::Begin("Display", open_ptr, window_flags);
ImGuiIO& io = ImGui::GetIO();
ImGui::Text("%.3f ms/frame (%.1f FPS)", (1000.0f / Global::fps()) , Global::fps());
ImGui::End();
ImGui::PopStyleColor(1);

21
modules/v4d/src/util.cpp
Unescape View File

@ -39,6 +39,24 @@ namespace cv {
namespace v4d {
namespace detail {
#ifdef __GNUG__
std::string demangle(const char* name) {
int status = -4; // some arbitrary value to eliminate the compiler warning
std::unique_ptr<char, void(*)(void*)> res {
abi::__cxa_demangle(name, NULL, NULL, &status),
std::free
};
return (status==0) ? res.get() : name ;
}
#else
// does nothing if not g++
std::string demangle(const char* name) {
return name;
}
#endif
size_t cnz(const cv::UMat& m) {
cv::UMat grey;
if(m.channels() == 1) {
@ -311,6 +329,7 @@ cv::Ptr<Sink> makeVaSink(cv::Ptr<V4D> window, const string& outputFilename, cons
cerr << "Using a VA sink" << endl;
if(writer->isOpened()) {
return new Sink([=](const uint64_t& seq, const cv::UMat& frame) {
CV_UNUSED(seq);
CLExecScope_t scope(window->sourceCtx()->getCLExecContext());
//FIXME cache it
cv::UMat converted;
@ -347,6 +366,7 @@ static cv::Ptr<Sink> makeAnyHWSink(const string& outputFilename, const int fourc
if(writer->isOpened()) {
return new Sink([=](const uint64_t& seq, const cv::UMat& frame) {
CV_UNUSED(seq);
cv::UMat converted;
cv::resize(frame, converted, frameSize);
cvtColor(converted, converted, cv::COLOR_BGRA2RGB);
@ -399,6 +419,7 @@ cv::Ptr<Sink> makeWriterSink(cv::Ptr<V4D> window, const string& outputFilename,
if(writer->isOpened()) {
return new Sink([=](const uint64_t& seq, const cv::UMat& frame) {
CV_UNUSED(seq);
cv::UMat converted;
cv::resize(frame, converted, frameSize);
cvtColor(converted, converted, cv::COLOR_BGRA2RGB);

Write Preview
Loading…
Cancel
Save