Compositor: Full frame Levels node
Adds full frame implementation to this node operations. No functional changes. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D11749
This commit is contained in:
parent
883fb49d4f
commit
e33814ef6b
|
|
@ -82,6 +82,7 @@ ExecutionSystem::ExecutionSystem(RenderData *rd,
|
|||
BLI_assert_msg(0, "Non implemented execution model");
|
||||
break;
|
||||
}
|
||||
num_work_threads_ = WorkScheduler::get_num_cpu_threads();
|
||||
}
|
||||
|
||||
ExecutionSystem::~ExecutionSystem()
|
||||
|
|
@ -130,7 +131,7 @@ void ExecutionSystem::execute_work(const rcti &work_rect,
|
|||
|
||||
/* Split work vertically to maximize continuous memory. */
|
||||
const int work_height = BLI_rcti_size_y(&work_rect);
|
||||
const int num_sub_works = MIN2(WorkScheduler::get_num_cpu_threads(), work_height);
|
||||
const int num_sub_works = MIN2(num_work_threads_, work_height);
|
||||
const int split_height = num_sub_works == 0 ? 0 : work_height / num_sub_works;
|
||||
int remaining_height = work_height - split_height * num_sub_works;
|
||||
|
||||
|
|
|
|||
|
|
@ -31,6 +31,7 @@ class ExecutionGroup;
|
|||
#include "DNA_node_types.h"
|
||||
|
||||
#include "BLI_vector.hh"
|
||||
#include "atomic_ops.h"
|
||||
|
||||
namespace blender::compositor {
|
||||
|
||||
|
|
@ -150,6 +151,11 @@ class ExecutionSystem {
|
|||
*/
|
||||
ExecutionModel *execution_model_;
|
||||
|
||||
/**
|
||||
* Number of cpu threads available for work execution.
|
||||
*/
|
||||
int num_work_threads_;
|
||||
|
||||
ThreadMutex work_mutex_;
|
||||
ThreadCondition work_finished_cond_;
|
||||
|
||||
|
|
@ -201,6 +207,27 @@ class ExecutionSystem {
|
|||
|
||||
void execute_work(const rcti &work_rect, std::function<void(const rcti &split_rect)> work_func);
|
||||
|
||||
/**
|
||||
* Multi-threadedly execute given work function passing work_rect splits as argument. On
|
||||
* finished, caller thread will call reduce_func for each thread result.
|
||||
*/
|
||||
template<typename TResult>
|
||||
void execute_work(const rcti &work_rect,
|
||||
std::function<TResult(const rcti &split_rect)> work_func,
|
||||
TResult &join,
|
||||
std::function<void(TResult &join, const TResult &chunk)> reduce_func)
|
||||
{
|
||||
Array<TResult> chunks(num_work_threads_);
|
||||
int num_started = 0;
|
||||
execute_work(work_rect, [&](const rcti &split_rect) {
|
||||
const int current = atomic_fetch_and_add_int32(&num_started, 1);
|
||||
chunks[current] = work_func(split_rect);
|
||||
});
|
||||
for (const int i : IndexRange(num_started)) {
|
||||
reduce_func(join, chunks[i]);
|
||||
}
|
||||
}
|
||||
|
||||
bool is_breaked() const;
|
||||
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@
|
|||
#include "COM_CalculateMeanOperation.h"
|
||||
#include "BLI_math.h"
|
||||
#include "BLI_utildefines.h"
|
||||
#include "COM_ExecutionSystem.h"
|
||||
|
||||
#include "IMB_colormanagement.h"
|
||||
|
||||
|
|
@ -128,4 +129,93 @@ void CalculateMeanOperation::calculateMean(MemoryBuffer *tile)
|
|||
this->m_result = sum / pixels;
|
||||
}
|
||||
|
||||
void CalculateMeanOperation::setSetting(int setting)
|
||||
{
|
||||
this->m_setting = setting;
|
||||
switch (setting) {
|
||||
case 1: {
|
||||
setting_func_ = IMB_colormanagement_get_luminance;
|
||||
break;
|
||||
}
|
||||
case 2: {
|
||||
setting_func_ = [](const float *elem) { return elem[0]; };
|
||||
break;
|
||||
}
|
||||
case 3: {
|
||||
setting_func_ = [](const float *elem) { return elem[1]; };
|
||||
break;
|
||||
}
|
||||
case 4: {
|
||||
setting_func_ = [](const float *elem) { return elem[2]; };
|
||||
break;
|
||||
}
|
||||
case 5: {
|
||||
setting_func_ = [](const float *elem) {
|
||||
float yuv[3];
|
||||
rgb_to_yuv(elem[0], elem[1], elem[2], &yuv[0], &yuv[1], &yuv[2], BLI_YUV_ITU_BT709);
|
||||
return yuv[0];
|
||||
};
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CalculateMeanOperation::get_area_of_interest(int input_idx,
|
||||
const rcti &UNUSED(output_area),
|
||||
rcti &r_input_area)
|
||||
{
|
||||
BLI_assert(input_idx == 0);
|
||||
NodeOperation *operation = getInputOperation(input_idx);
|
||||
r_input_area.xmin = 0;
|
||||
r_input_area.ymin = 0;
|
||||
r_input_area.xmax = operation->getWidth();
|
||||
r_input_area.ymax = operation->getHeight();
|
||||
}
|
||||
|
||||
void CalculateMeanOperation::update_memory_buffer_started(MemoryBuffer *UNUSED(output),
|
||||
const rcti &UNUSED(area),
|
||||
Span<MemoryBuffer *> inputs)
|
||||
{
|
||||
if (!this->m_iscalculated) {
|
||||
MemoryBuffer *input = inputs[0];
|
||||
m_result = calc_mean(input);
|
||||
this->m_iscalculated = true;
|
||||
}
|
||||
}
|
||||
|
||||
void CalculateMeanOperation::update_memory_buffer_partial(MemoryBuffer *output,
|
||||
const rcti &area,
|
||||
Span<MemoryBuffer *> UNUSED(inputs))
|
||||
{
|
||||
output->fill(area, &m_result);
|
||||
}
|
||||
|
||||
float CalculateMeanOperation::calc_mean(const MemoryBuffer *input)
|
||||
{
|
||||
PixelsSum total = {0};
|
||||
exec_system_->execute_work<PixelsSum>(
|
||||
input->get_rect(),
|
||||
[=](const rcti &split) { return calc_area_sum(input, split); },
|
||||
total,
|
||||
[](PixelsSum &join, const PixelsSum &chunk) {
|
||||
join.sum += chunk.sum;
|
||||
join.num_pixels += chunk.num_pixels;
|
||||
});
|
||||
return total.num_pixels == 0 ? 0.0f : total.sum / total.num_pixels;
|
||||
}
|
||||
|
||||
using PixelsSum = CalculateMeanOperation::PixelsSum;
|
||||
PixelsSum CalculateMeanOperation::calc_area_sum(const MemoryBuffer *input, const rcti &area)
|
||||
{
|
||||
PixelsSum result = {0};
|
||||
for (const float *elem : input->get_buffer_area(area)) {
|
||||
if (elem[3] <= 0.0f) {
|
||||
continue;
|
||||
}
|
||||
result.sum += setting_func_(elem);
|
||||
result.num_pixels++;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
} // namespace blender::compositor
|
||||
|
|
|
|||
|
|
@ -18,8 +18,9 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include "COM_NodeOperation.h"
|
||||
#include "COM_MultiThreadedOperation.h"
|
||||
#include "DNA_node_types.h"
|
||||
#include <functional>
|
||||
|
||||
namespace blender::compositor {
|
||||
|
||||
|
|
@ -27,7 +28,13 @@ namespace blender::compositor {
|
|||
* \brief base class of CalculateMean, implementing the simple CalculateMean
|
||||
* \ingroup operation
|
||||
*/
|
||||
class CalculateMeanOperation : public NodeOperation {
|
||||
class CalculateMeanOperation : public MultiThreadedOperation {
|
||||
public:
|
||||
struct PixelsSum {
|
||||
float sum;
|
||||
int num_pixels;
|
||||
};
|
||||
|
||||
protected:
|
||||
/**
|
||||
* \brief Cached reference to the reader
|
||||
|
|
@ -37,6 +44,7 @@ class CalculateMeanOperation : public NodeOperation {
|
|||
bool m_iscalculated;
|
||||
float m_result;
|
||||
int m_setting;
|
||||
std::function<float(const float *elem)> setting_func_;
|
||||
|
||||
public:
|
||||
CalculateMeanOperation();
|
||||
|
|
@ -61,13 +69,24 @@ class CalculateMeanOperation : public NodeOperation {
|
|||
bool determineDependingAreaOfInterest(rcti *input,
|
||||
ReadBufferOperation *readOperation,
|
||||
rcti *output) override;
|
||||
void setSetting(int setting)
|
||||
{
|
||||
this->m_setting = setting;
|
||||
}
|
||||
void setSetting(int setting);
|
||||
|
||||
void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area) override;
|
||||
|
||||
virtual void update_memory_buffer_started(MemoryBuffer *output,
|
||||
const rcti &area,
|
||||
Span<MemoryBuffer *> inputs) override;
|
||||
|
||||
virtual void update_memory_buffer_partial(MemoryBuffer *output,
|
||||
const rcti &area,
|
||||
Span<MemoryBuffer *> inputs) override;
|
||||
|
||||
protected:
|
||||
void calculateMean(MemoryBuffer *tile);
|
||||
float calc_mean(const MemoryBuffer *input);
|
||||
|
||||
private:
|
||||
PixelsSum calc_area_sum(const MemoryBuffer *input, const rcti &area);
|
||||
};
|
||||
|
||||
} // namespace blender::compositor
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@
|
|||
#include "COM_CalculateStandardDeviationOperation.h"
|
||||
#include "BLI_math.h"
|
||||
#include "BLI_utildefines.h"
|
||||
#include "COM_ExecutionSystem.h"
|
||||
|
||||
#include "IMB_colormanagement.h"
|
||||
|
||||
|
|
@ -96,4 +97,50 @@ void *CalculateStandardDeviationOperation::initializeTileData(rcti *rect)
|
|||
return nullptr;
|
||||
}
|
||||
|
||||
void CalculateStandardDeviationOperation::update_memory_buffer_started(
|
||||
MemoryBuffer *UNUSED(output), const rcti &UNUSED(area), Span<MemoryBuffer *> inputs)
|
||||
{
|
||||
if (!this->m_iscalculated) {
|
||||
const MemoryBuffer *input = inputs[0];
|
||||
const float mean = CalculateMeanOperation::calc_mean(input);
|
||||
|
||||
PixelsSum total = {0};
|
||||
exec_system_->execute_work<PixelsSum>(
|
||||
input->get_rect(),
|
||||
[=](const rcti &split) { return calc_area_sum(input, split, mean); },
|
||||
total,
|
||||
[](PixelsSum &join, const PixelsSum &chunk) {
|
||||
join.sum += chunk.sum;
|
||||
join.num_pixels += chunk.num_pixels;
|
||||
});
|
||||
this->m_standardDeviation = total.num_pixels <= 1 ?
|
||||
0.0f :
|
||||
sqrt(total.sum / (float)(total.num_pixels - 1));
|
||||
this->m_iscalculated = true;
|
||||
}
|
||||
}
|
||||
|
||||
void CalculateStandardDeviationOperation::update_memory_buffer_partial(
|
||||
MemoryBuffer *output, const rcti &area, Span<MemoryBuffer *> UNUSED(inputs))
|
||||
{
|
||||
output->fill(area, &m_standardDeviation);
|
||||
}
|
||||
|
||||
using PixelsSum = CalculateMeanOperation::PixelsSum;
|
||||
PixelsSum CalculateStandardDeviationOperation::calc_area_sum(const MemoryBuffer *input,
|
||||
const rcti &area,
|
||||
const float mean)
|
||||
{
|
||||
PixelsSum result = {0};
|
||||
for (const float *elem : input->get_buffer_area(area)) {
|
||||
if (elem[3] <= 0.0f) {
|
||||
continue;
|
||||
}
|
||||
const float value = setting_func_(elem);
|
||||
result.sum += (value - mean) * (value - mean);
|
||||
result.num_pixels++;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
} // namespace blender::compositor
|
||||
|
|
|
|||
|
|
@ -40,6 +40,17 @@ class CalculateStandardDeviationOperation : public CalculateMeanOperation {
|
|||
void executePixel(float output[4], int x, int y, void *data) override;
|
||||
|
||||
void *initializeTileData(rcti *rect) override;
|
||||
|
||||
void update_memory_buffer_started(MemoryBuffer *output,
|
||||
const rcti &area,
|
||||
Span<MemoryBuffer *> inputs) override;
|
||||
|
||||
void update_memory_buffer_partial(MemoryBuffer *output,
|
||||
const rcti &area,
|
||||
Span<MemoryBuffer *> inputs) override;
|
||||
|
||||
private:
|
||||
PixelsSum calc_area_sum(const MemoryBuffer *input, const rcti &area, float mean);
|
||||
};
|
||||
|
||||
} // namespace blender::compositor
|
||||
|
|
|
|||
Loading…
Reference in New Issue