kallaballa
2 years ago
parent
df33e5e3a7
commit
23a83adb23
72 changed files with 1423 additions and 1220 deletions
|
After Width: | Height: | Size: 463 KiB |
@ -1,381 +0,0 @@ |
|||||||
// cxxpool is a header-only thread pool for C++
|
|
||||||
// Repository: https://github.com/bloomen/cxxpool
|
|
||||||
// Copyright: 2022 Christian Blume
|
|
||||||
// License: http://www.opensource.org/licenses/mit-license.php
|
|
||||||
#pragma once |
|
||||||
#include <thread> |
|
||||||
#include <mutex> |
|
||||||
#include <future> |
|
||||||
#include <stdexcept> |
|
||||||
#include <queue> |
|
||||||
#include <utility> |
|
||||||
#include <functional> |
|
||||||
#include <vector> |
|
||||||
#include <chrono> |
|
||||||
#include <cstddef> |
|
||||||
|
|
||||||
|
|
||||||
namespace cxxpool { |
|
||||||
namespace detail { |
|
||||||
|
|
||||||
|
|
||||||
template<typename Iterator> |
|
||||||
struct future_info { |
|
||||||
typedef typename std::iterator_traits<Iterator>::value_type future_type; |
|
||||||
typedef decltype(std::declval<future_type>().get()) value_type; |
|
||||||
static constexpr bool is_void = std::is_void<value_type>::value; |
|
||||||
}; |
|
||||||
|
|
||||||
|
|
||||||
} // detail
|
|
||||||
|
|
||||||
|
|
||||||
// Waits until all futures contain results
|
|
||||||
template<typename Iterator> |
|
||||||
inline |
|
||||||
void wait(Iterator first, Iterator last) { |
|
||||||
for (; first != last; ++first) |
|
||||||
first->wait(); |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
// Waits until all futures contain results with a given timeout duration and
|
|
||||||
// returns a container of std::future::status
|
|
||||||
template<typename Result, typename Iterator, typename Rep, typename Period> |
|
||||||
inline |
|
||||||
Result wait_for(Iterator first, Iterator last, |
|
||||||
const std::chrono::duration<Rep, Period>& timeout_duration, |
|
||||||
Result result) { |
|
||||||
for (; first != last; ++first) |
|
||||||
result.push_back(first->wait_for(timeout_duration)); |
|
||||||
return result; |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
// Waits until all futures contain results with a given timeout duration and
|
|
||||||
// returns a vector of std::future::status
|
|
||||||
template<typename Iterator, typename Rep, typename Period> |
|
||||||
inline |
|
||||||
std::vector<std::future_status> wait_for(Iterator first, Iterator last, |
|
||||||
const std::chrono::duration<Rep, Period>& timeout_duration) { |
|
||||||
return wait_for(first, last, timeout_duration, std::vector<std::future_status>{}); |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
// Waits until all futures contain results with a given timeout time and
|
|
||||||
// returns a container of std::future::status
|
|
||||||
template<typename Result, typename Iterator, typename Clock, typename Duration> |
|
||||||
inline |
|
||||||
Result wait_until(Iterator first, Iterator last, |
|
||||||
const std::chrono::time_point<Clock, Duration>& timeout_time, |
|
||||||
Result result) { |
|
||||||
for (; first != last; ++first) |
|
||||||
result.push_back(first->wait_until(timeout_time)); |
|
||||||
return result; |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
// Waits until all futures contain results with a given timeout time and
|
|
||||||
// returns a vector of std::future::status
|
|
||||||
template<typename Iterator, typename Clock, typename Duration> |
|
||||||
inline |
|
||||||
std::vector<std::future_status> wait_until(Iterator first, Iterator last, |
|
||||||
const std::chrono::time_point<Clock, Duration>& timeout_time) { |
|
||||||
return wait_until(first, last, timeout_time, std::vector<std::future_status>{}); |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
// Calls get() on all futures
|
|
||||||
template<typename Iterator, |
|
||||||
typename = typename std::enable_if<cxxpool::detail::future_info<Iterator>::is_void>::type> |
|
||||||
inline |
|
||||||
void get(Iterator first, Iterator last) { |
|
||||||
for (; first != last; ++first) |
|
||||||
first->get(); |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
// Calls get() on all futures and stores the results in the returned container
|
|
||||||
template<typename Result, typename Iterator, |
|
||||||
typename = typename std::enable_if<!cxxpool::detail::future_info<Iterator>::is_void>::type> |
|
||||||
inline |
|
||||||
Result get(Iterator first, Iterator last, Result result) { |
|
||||||
for (; first != last; ++first) |
|
||||||
result.push_back(first->get()); |
|
||||||
return result; |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
// Calls get() on all futures and stores the results in the returned vector
|
|
||||||
template<typename Iterator, |
|
||||||
typename = typename std::enable_if<!detail::future_info<Iterator>::is_void>::type> |
|
||||||
inline |
|
||||||
std::vector<typename detail::future_info<Iterator>::value_type> |
|
||||||
get(Iterator first, Iterator last) { |
|
||||||
return cxxpool::get(first, last, std::vector<typename cxxpool::detail::future_info<Iterator>::value_type>{}); |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
namespace detail { |
|
||||||
|
|
||||||
|
|
||||||
template<typename Index, Index max = std::numeric_limits<Index>::max()> |
|
||||||
class infinite_counter { |
|
||||||
public: |
|
||||||
|
|
||||||
infinite_counter() |
|
||||||
: count_{0} |
|
||||||
{} |
|
||||||
|
|
||||||
infinite_counter& operator++() { |
|
||||||
if (count_.back() == max) |
|
||||||
count_.push_back(0); |
|
||||||
else |
|
||||||
++count_.back(); |
|
||||||
return *this; |
|
||||||
} |
|
||||||
|
|
||||||
bool operator>(const infinite_counter& other) const { |
|
||||||
if (count_.size() == other.count_.size()) { |
|
||||||
return count_.back() > other.count_.back(); |
|
||||||
} else { |
|
||||||
return count_.size() > other.count_.size(); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
private: |
|
||||||
std::vector<Index> count_; |
|
||||||
}; |
|
||||||
|
|
||||||
|
|
||||||
class priority_task { |
|
||||||
public: |
|
||||||
typedef std::size_t counter_elem_t; |
|
||||||
|
|
||||||
priority_task() |
|
||||||
: callback_{}, priority_{}, order_{} |
|
||||||
{} |
|
||||||
|
|
||||||
// cppcheck-suppress passedByValue
|
|
||||||
priority_task(std::function<void()> callback, std::size_t priority, cxxpool::detail::infinite_counter<counter_elem_t> order) |
|
||||||
: callback_{std::move(callback)}, priority_(priority), order_{std::move(order)} |
|
||||||
{} |
|
||||||
|
|
||||||
bool operator<(const priority_task& other) const { |
|
||||||
if (priority_ == other.priority_) { |
|
||||||
return order_ > other.order_; |
|
||||||
} else { |
|
||||||
return priority_ < other.priority_; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
void operator()() const { |
|
||||||
return callback_(); |
|
||||||
} |
|
||||||
|
|
||||||
private: |
|
||||||
std::function<void()> callback_; |
|
||||||
std::size_t priority_; |
|
||||||
cxxpool::detail::infinite_counter<counter_elem_t> order_; |
|
||||||
}; |
|
||||||
|
|
||||||
|
|
||||||
} // detail
|
|
||||||
|
|
||||||
|
|
||||||
// Exception thrown by the thread_pool class
|
|
||||||
class thread_pool_error : public std::runtime_error { |
|
||||||
public: |
|
||||||
explicit thread_pool_error(const std::string& message) |
|
||||||
: std::runtime_error{message} |
|
||||||
{} |
|
||||||
}; |
|
||||||
|
|
||||||
|
|
||||||
// A thread pool for C++
|
|
||||||
//
|
|
||||||
// Constructing the thread pool launches the worker threads while
|
|
||||||
// destructing it joins them. The threads will be alive for as long as the
|
|
||||||
// thread pool is not destructed. One may call add_threads() to add more
|
|
||||||
// threads to the thread pool.
|
|
||||||
//
|
|
||||||
// Tasks can be pushed into the pool with and w/o providing a priority >= 0.
|
|
||||||
// Not providing a priority is equivalent to providing a priority of 0.
|
|
||||||
// Those tasks are processed first that have the highest priority.
|
|
||||||
// If priorities are equal those tasks are processed first that were pushed
|
|
||||||
// first into the pool (FIFO).
|
|
||||||
class thread_pool { |
|
||||||
public: |
|
||||||
|
|
||||||
// Constructor. No threads are launched
|
|
||||||
thread_pool() |
|
||||||
: done_{false}, paused_{false}, threads_{}, tasks_{}, task_counter_{}, |
|
||||||
task_cond_var_{}, task_mutex_{}, thread_mutex_{} |
|
||||||
{} |
|
||||||
|
|
||||||
// Constructor. Launches the desired number of threads. Passing 0 is
|
|
||||||
// equivalent to calling the no-argument constructor
|
|
||||||
explicit thread_pool(std::size_t n_threads) |
|
||||||
: thread_pool{} |
|
||||||
{ |
|
||||||
if (n_threads > 0) { |
|
||||||
std::lock_guard<std::mutex> thread_lock(thread_mutex_); |
|
||||||
const auto n_target = threads_.size() + n_threads; |
|
||||||
while (threads_.size() < n_target) { |
|
||||||
std::thread thread; |
|
||||||
try { |
|
||||||
thread = std::thread{&thread_pool::worker, this}; |
|
||||||
} catch (...) { |
|
||||||
shutdown(); |
|
||||||
throw; |
|
||||||
} |
|
||||||
try { |
|
||||||
threads_.push_back(std::move(thread)); |
|
||||||
} catch (...) { |
|
||||||
shutdown(); |
|
||||||
thread.join(); |
|
||||||
throw; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Destructor. Joins all threads launched. Waits for all running tasks
|
|
||||||
// to complete
|
|
||||||
~thread_pool() { |
|
||||||
shutdown(); |
|
||||||
} |
|
||||||
|
|
||||||
// deleting copy/move semantics
|
|
||||||
thread_pool(const thread_pool&) = delete; |
|
||||||
thread_pool& operator=(const thread_pool&) = delete; |
|
||||||
thread_pool(thread_pool&&) = delete; |
|
||||||
thread_pool& operator=(thread_pool&&) = delete; |
|
||||||
|
|
||||||
// Adds new threads to the pool and launches them
|
|
||||||
void add_threads(std::size_t n_threads) { |
|
||||||
if (n_threads > 0) { |
|
||||||
{ |
|
||||||
std::lock_guard<std::mutex> task_lock(task_mutex_); |
|
||||||
if (done_) |
|
||||||
throw thread_pool_error{"add_threads called while pool is shutting down"}; |
|
||||||
} |
|
||||||
std::lock_guard<std::mutex> thread_lock(thread_mutex_); |
|
||||||
const auto n_target = threads_.size() + n_threads; |
|
||||||
while (threads_.size() < n_target) { |
|
||||||
std::thread thread(&thread_pool::worker, this); |
|
||||||
try { |
|
||||||
threads_.push_back(std::move(thread)); |
|
||||||
} catch (...) { |
|
||||||
shutdown(); |
|
||||||
thread.join(); |
|
||||||
throw; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Returns the number of threads launched
|
|
||||||
std::size_t n_threads() const { |
|
||||||
{ |
|
||||||
std::lock_guard<std::mutex> task_lock(task_mutex_); |
|
||||||
if (done_) |
|
||||||
throw thread_pool_error{"n_threads called while pool is shutting down"}; |
|
||||||
} |
|
||||||
std::lock_guard<std::mutex> thread_lock(thread_mutex_); |
|
||||||
return threads_.size(); |
|
||||||
} |
|
||||||
|
|
||||||
// Pushes a new task into the thread pool and returns the associated future.
|
|
||||||
// The task will have a priority of 0
|
|
||||||
template<typename Functor, typename... Args> |
|
||||||
auto push(Functor&& functor, Args&&... args) -> std::future<decltype(functor(args...))> { |
|
||||||
return push(0, std::forward<Functor>(functor), std::forward<Args>(args)...); |
|
||||||
} |
|
||||||
|
|
||||||
// Pushes a new task into the thread pool while providing a priority and
|
|
||||||
// returns the associated future. Higher priorities are processed first
|
|
||||||
template<typename Functor, typename... Args> |
|
||||||
auto push(std::size_t priority, Functor&& functor, Args&&... args) -> std::future<decltype(functor(args...))> { |
|
||||||
typedef decltype(functor(args...)) result_type; |
|
||||||
auto pack_task = std::make_shared<std::packaged_task<result_type()>>( |
|
||||||
std::bind(std::forward<Functor>(functor), std::forward<Args>(args)...)); |
|
||||||
auto future = pack_task->get_future(); |
|
||||||
{ |
|
||||||
std::lock_guard<std::mutex> task_lock(task_mutex_); |
|
||||||
if (done_) |
|
||||||
throw cxxpool::thread_pool_error{"push called while pool is shutting down"}; |
|
||||||
tasks_.emplace([pack_task]{ (*pack_task)(); }, priority, ++task_counter_); |
|
||||||
} |
|
||||||
task_cond_var_.notify_one(); |
|
||||||
return future; |
|
||||||
} |
|
||||||
|
|
||||||
// Returns the current number of queued tasks
|
|
||||||
std::size_t n_tasks() const { |
|
||||||
std::lock_guard<std::mutex> task_lock(task_mutex_); |
|
||||||
return tasks_.size(); |
|
||||||
} |
|
||||||
|
|
||||||
// Clears all queued tasks, not affecting currently running tasks
|
|
||||||
void clear() { |
|
||||||
std::lock_guard<std::mutex> task_lock(task_mutex_); |
|
||||||
decltype(tasks_) empty; |
|
||||||
tasks_.swap(empty); |
|
||||||
} |
|
||||||
|
|
||||||
// If enabled then pauses the processing of tasks, not affecting currently
|
|
||||||
// running tasks. Disabling it will resume the processing of tasks
|
|
||||||
void set_pause(bool enabled) { |
|
||||||
{ |
|
||||||
std::lock_guard<std::mutex> task_lock(task_mutex_); |
|
||||||
paused_ = enabled; |
|
||||||
} |
|
||||||
if (!paused_) |
|
||||||
task_cond_var_.notify_all(); |
|
||||||
} |
|
||||||
|
|
||||||
private: |
|
||||||
|
|
||||||
void worker() { |
|
||||||
for (;;) { |
|
||||||
cxxpool::detail::priority_task task; |
|
||||||
{ |
|
||||||
std::unique_lock<std::mutex> task_lock(task_mutex_); |
|
||||||
task_cond_var_.wait(task_lock, [this]{ |
|
||||||
return !paused_ && (done_ || !tasks_.empty()); |
|
||||||
}); |
|
||||||
if (done_ && tasks_.empty()) |
|
||||||
break; |
|
||||||
task = tasks_.top(); |
|
||||||
tasks_.pop(); |
|
||||||
} |
|
||||||
task(); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
void shutdown() { |
|
||||||
{ |
|
||||||
std::lock_guard<std::mutex> task_lock(task_mutex_); |
|
||||||
done_ = true; |
|
||||||
paused_ = false; |
|
||||||
} |
|
||||||
task_cond_var_.notify_all(); |
|
||||||
std::lock_guard<std::mutex> thread_lock(thread_mutex_); |
|
||||||
for (auto& thread : threads_) |
|
||||||
thread.join(); |
|
||||||
} |
|
||||||
|
|
||||||
bool done_; |
|
||||||
bool paused_; |
|
||||||
std::vector<std::thread> threads_; |
|
||||||
std::priority_queue<cxxpool::detail::priority_task> tasks_; |
|
||||||
cxxpool::detail::infinite_counter< |
|
||||||
typename detail::priority_task::counter_elem_t> task_counter_; |
|
||||||
std::condition_variable task_cond_var_; |
|
||||||
mutable std::mutex task_mutex_; |
|
||||||
mutable std::mutex thread_mutex_; |
|
||||||
}; |
|
||||||
|
|
||||||
|
|
||||||
} // cxxpool
|
|
||||||
@ -0,0 +1,132 @@ |
|||||||
|
/*
|
||||||
|
* Simple header-only thread pool implementation in modern C++. |
||||||
|
* |
||||||
|
* Created: Aug 9, 2020. |
||||||
|
* Repository: https://github.com/leiless/threadpool.hpp
|
||||||
|
* LICENSE: BSD-2-Clause |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef THE_THREADPOOL_HPP |
||||||
|
#define THE_THREADPOOL_HPP |
||||||
|
|
||||||
|
#include <functional> |
||||||
|
#include <mutex> |
||||||
|
#include <condition_variable> |
||||||
|
#include <queue> |
||||||
|
#include <thread> |
||||||
|
#include <future> |
||||||
|
|
||||||
|
#define THE_NAMESPACE_BEGIN(name) namespace name { |
||||||
|
#define THE_NAMESPACE_END() } |
||||||
|
|
||||||
|
THE_NAMESPACE_BEGIN(concurrent) |
||||||
|
|
||||||
|
class threadpool { |
||||||
|
public: |
||||||
|
explicit threadpool(size_t threads) : alive(true) { |
||||||
|
if (threads == 0) { |
||||||
|
throw std::runtime_error("thread pool size cannot be zero"); |
||||||
|
} |
||||||
|
|
||||||
|
for (auto i = 0llu; i < threads; i++) { |
||||||
|
std::cerr << "work" << std::endl; |
||||||
|
workers.emplace_back([this] { worker_main(); }); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// see: https://stackoverflow.com/a/23771245/13600780
|
||||||
|
threadpool(const threadpool &) = delete; |
||||||
|
threadpool & operator=(const threadpool &) = delete; |
||||||
|
|
||||||
|
~threadpool() noexcept { |
||||||
|
{ |
||||||
|
std::lock_guard<decltype(mtx)> lock(mtx); |
||||||
|
alive = false; |
||||||
|
} |
||||||
|
|
||||||
|
cv.notify_all(); |
||||||
|
|
||||||
|
for (auto & worker : workers) { |
||||||
|
worker.join(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
template<typename Fn, typename... Args> |
||||||
|
decltype(auto) enqueue(Fn && fn, Args &&... args) { |
||||||
|
return enqueue(false, fn, args...); |
||||||
|
} |
||||||
|
|
||||||
|
template<typename Fn, typename... Args> |
||||||
|
decltype(auto) enqueue_r(Fn && fn, Args &&... args) { |
||||||
|
return enqueue(true, fn, args...); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
template<typename Fn, typename... Args> |
||||||
|
decltype(auto) enqueue(bool block_on_shutdown, Fn && fn, Args &&... args) { |
||||||
|
using return_type = std::invoke_result_t<Fn, Args...>; |
||||||
|
using pack_task = std::packaged_task<return_type()>; |
||||||
|
|
||||||
|
auto t = std::make_shared<pack_task>( |
||||||
|
std::bind(std::forward<Fn>(fn), std::forward<Args>(args)...) |
||||||
|
); |
||||||
|
auto future = t->get_future(); |
||||||
|
|
||||||
|
{ |
||||||
|
std::lock_guard<decltype(mtx)> lock(mtx); |
||||||
|
if (!alive) { |
||||||
|
throw std::runtime_error("enqueue on stopped thread pool"); |
||||||
|
} |
||||||
|
tasks.emplace([t = std::move(t)] { (*t)(); }, block_on_shutdown); |
||||||
|
} |
||||||
|
|
||||||
|
cv.notify_one(); |
||||||
|
return future; |
||||||
|
} |
||||||
|
|
||||||
|
using task = std::pair<std::function<void()>, bool>; |
||||||
|
|
||||||
|
[[nodiscard]] inline task poll_task() noexcept { |
||||||
|
task t; |
||||||
|
|
||||||
|
std::unique_lock<decltype(mtx)> lock(mtx); |
||||||
|
cv.wait(lock, [this] { return !tasks.empty() || !alive; }); |
||||||
|
|
||||||
|
while (!tasks.empty()) { |
||||||
|
if (!alive && !tasks.front().second) { |
||||||
|
tasks.pop(); |
||||||
|
continue; |
||||||
|
} |
||||||
|
|
||||||
|
t = std::move(tasks.front()); |
||||||
|
tasks.pop(); |
||||||
|
break; |
||||||
|
} |
||||||
|
|
||||||
|
return t; |
||||||
|
} |
||||||
|
|
||||||
|
void worker_main() { |
||||||
|
while (true) { |
||||||
|
std::cerr << "I" << std::endl; |
||||||
|
task t = poll_task(); |
||||||
|
std::cerr << "II" << std::endl; |
||||||
|
// The thread pool is going to shutdown
|
||||||
|
if (t.first == nullptr) break; |
||||||
|
std::cerr << "III" << std::endl; |
||||||
|
t.first(); |
||||||
|
std::cerr << "IIII" << std::endl; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
bool alive; |
||||||
|
std::mutex mtx; |
||||||
|
std::condition_variable cv; |
||||||
|
std::queue<task> tasks; |
||||||
|
std::vector<std::thread> workers; |
||||||
|
}; |
||||||
|
|
||||||
|
THE_NAMESPACE_END() |
||||||
|
|
||||||
|
#endif |
||||||
|
|
||||||
@ -0,0 +1,45 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
// Copyright Amir Hassan (kallaballa) <amir@viel-zu.org>
|
||||||
|
|
||||||
|
#include "nanoguicontext.hpp" |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace v4d { |
||||||
|
namespace detail { |
||||||
|
NanoguiContext::NanoguiContext(V4D& v4d, FrameBufferContext& fbContext) : |
||||||
|
mainFbContext_(fbContext), nguiFbContext_(v4d, "NanoGUI", fbContext) { |
||||||
|
fbCtx().makeCurrent(); |
||||||
|
screen_ = new nanogui::Screen(); |
||||||
|
screen_->initialize(nguiFbContext_.getGLFWWindow(), false); |
||||||
|
form_ = new cv::v4d::FormHelper(screen_); |
||||||
|
fbCtx().resizeWindow(fbCtx().getSize()); |
||||||
|
fbCtx().makeNoneCurrent(); |
||||||
|
} |
||||||
|
|
||||||
|
void NanoguiContext::render() { |
||||||
|
screen().draw_widgets(); |
||||||
|
} |
||||||
|
|
||||||
|
void NanoguiContext::build(std::function<void(cv::v4d::FormHelper&)> fn) { |
||||||
|
fbCtx().makeCurrent(); |
||||||
|
fn(form()); |
||||||
|
screen().perform_layout(); |
||||||
|
fbCtx().makeNoneCurrent(); |
||||||
|
} |
||||||
|
|
||||||
|
nanogui::Screen& NanoguiContext::screen() { |
||||||
|
return *screen_; |
||||||
|
} |
||||||
|
|
||||||
|
cv::v4d::FormHelper& NanoguiContext::form() { |
||||||
|
return *form_; |
||||||
|
} |
||||||
|
|
||||||
|
FrameBufferContext& NanoguiContext::fbCtx() { |
||||||
|
return nguiFbContext_; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,44 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
// Copyright Amir Hassan (kallaballa) <amir@viel-zu.org>
|
||||||
|
|
||||||
|
#ifndef SRC_OPENCV_NANOGUICONTEXT_HPP_ |
||||||
|
#define SRC_OPENCV_NANOGUICONTEXT_HPP_ |
||||||
|
|
||||||
|
#include "framebuffercontext.hpp" |
||||||
|
|
||||||
|
#ifdef __EMSCRIPTEN__ |
||||||
|
#include <emscripten.h> |
||||||
|
#endif |
||||||
|
|
||||||
|
#include <opencv2/v4d/formhelper.hpp> |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace v4d { |
||||||
|
namespace detail { |
||||||
|
/*!
|
||||||
|
* Used to setup a nanogui context |
||||||
|
*/ |
||||||
|
class NanoguiContext { |
||||||
|
nanogui::Screen* screen_; |
||||||
|
cv::v4d::FormHelper* form_; |
||||||
|
FrameBufferContext& mainFbContext_; |
||||||
|
FrameBufferContext nguiFbContext_; |
||||||
|
cv::UMat preFB_; |
||||||
|
cv::UMat fb_; |
||||||
|
cv::UMat postFB_; |
||||||
|
public: |
||||||
|
NanoguiContext(V4D& v4d, FrameBufferContext& fbContext); |
||||||
|
void render(); |
||||||
|
void build(std::function<void(cv::v4d::FormHelper&)> fn); |
||||||
|
nanogui::Screen& screen(); |
||||||
|
cv::v4d::FormHelper& form(); |
||||||
|
|
||||||
|
FrameBufferContext& fbCtx(); |
||||||
|
}; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
#endif /* SRC_OPENCV_NANOGUICONTEXT_HPP_ */ |
||||||
@ -0,0 +1,16 @@ |
|||||||
|
# Display an image using direct framebuffer access {#v4d_display_image_fb} |
||||||
|
|
||||||
|
@prev_tutorial{v4d_display_image_pipeline} |
||||||
|
@next_tutorial{v4d_vector_graphics} |
||||||
|
|
||||||
|
| | | |
||||||
|
| -: | :- | |
||||||
|
| Original author | Amir Hassan (kallaballa) <amir@viel-zu.org> | |
||||||
|
| Compatibility | OpenCV >= 4.7 | |
||||||
|
|
||||||
|
## Using direct framebuffer access |
||||||
|
Instead of feeding to the video pipeline we can request the framebuffer in a ```fb``` context and copy the image to it. But first we must manually resize and color convert the image. |
||||||
|
|
||||||
|
\htmlinclude "../samples/example_v4d_display_image_fb.html" |
||||||
|
|
||||||
|
@include samples/display_image_fb.cpp |
||||||
@ -0,0 +1,16 @@ |
|||||||
|
# Render vector graphics {#v4d_vector_graphics} |
||||||
|
|
||||||
|
@prev_tutorial{v4d_display_image_fb} |
||||||
|
@next_tutorial{v4d_vector_graphics_and_fb} |
||||||
|
|
||||||
|
| | | |
||||||
|
| -: | :- | |
||||||
|
| Original author | Amir Hassan (kallaballa) <amir@viel-zu.org> | |
||||||
|
| Compatibility | OpenCV >= 4.7 | |
||||||
|
|
||||||
|
## Vector graphics |
||||||
|
Through the nvg context javascript-canvas-like rendering is possible. |
||||||
|
|
||||||
|
\htmlinclude "../samples/example_v4d_vector_graphics.html" |
||||||
|
|
||||||
|
@include samples/vector_graphics.cpp |
||||||
Loading…
Reference in new issue