Blender V5.3
node_composite_levels.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2006 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "BLI_math_vector.hh"
7
8#include "RNA_types.hh"
9
11
13#include "COM_node_operation.hh"
14
16
18
20 {CMP_NODE_LEVLES_LUMINANCE, "COMBINED_RGB", 0, N_("Combined"), N_("Combined RGB")},
21 {CMP_NODE_LEVLES_RED, "RED", 0, N_("Red"), N_("Red Channel")},
22 {CMP_NODE_LEVLES_GREEN, "GREEN", 0, N_("Green"), N_("Green Channel")},
23 {CMP_NODE_LEVLES_BLUE, "BLUE", 0, N_("Blue"), N_("Blue Channel")},
24 {CMP_NODE_LEVLES_LUMINANCE_BT709, "LUMINANCE", 0, N_("Luminance"), N_("Luminance Channel")},
25 {0, nullptr, 0, nullptr, nullptr},
26};
27
29{
30 b.add_input<decl::Color>("Image"_ustr)
31 .default_value({0.0f, 0.0f, 0.0f, 1.0f})
32 .structure_type(StructureType::Dynamic);
33 b.add_input<decl::Menu>("Channel"_ustr)
34 .default_value(CMP_NODE_LEVLES_LUMINANCE)
35 .static_items(channel_items)
37
38 b.add_output<decl::Float>("Mean"_ustr);
39 b.add_output<decl::Float>("Standard Deviation"_ustr);
40 b.add_output<decl::Float>("Minimum"_ustr);
41 b.add_output<decl::Float>("Maximum"_ustr);
42}
43
44using namespace blender::compositor;
45
47 private:
48 constexpr static float luminance_coefficients_bt709_[3] = {0.2126f, 0.7152f, 0.0722f};
49
50 public:
52
53 void execute() override
54 {
55 if (this->get_input("Image").is_single_value()) {
57 return;
58 }
59
60 const float4 mean = this->compute_mean();
61
62 Result &mean_result = this->get_result("Mean");
63 if (mean_result.should_compute()) {
64 mean_result.allocate_single_value();
65 this->set_output(mean, mean_result);
66 }
67
68 Result &standard_deviation_result = this->get_result("Standard Deviation");
69 if (standard_deviation_result.should_compute()) {
70 const float4 standard_deviation = this->compute_standard_deviation(mean);
71 standard_deviation_result.allocate_single_value();
72 this->set_output(standard_deviation, standard_deviation_result);
73 }
74
75 const Color minimum = minimum_color(this->context(), this->get_input("Image"));
76 Result &minimum_result = this->get_result("Minimum");
77 if (minimum_result.should_compute()) {
78 minimum_result.allocate_single_value();
79 this->set_output(float4(minimum), minimum_result);
80 }
81
82 const Color maximum = maximum_color(this->context(), this->get_input("Image"));
83 Result &maximum_result = this->get_result("Maximum");
84 if (maximum_result.should_compute()) {
85 maximum_result.allocate_single_value();
86 this->set_output(float4(maximum), maximum_result);
87 }
88 }
89
91 {
92 Result &minimum_result = this->get_result("Minimum");
93 if (minimum_result.should_compute()) {
94 minimum_result.allocate_single_value();
95 this->set_output(float4(this->get_input("Image").get_single_value<Color>()), minimum_result);
96 }
97
98 Result &maximum_result = this->get_result("Maximum");
99 if (maximum_result.should_compute()) {
100 maximum_result.allocate_single_value();
101 this->set_output(float4(this->get_input("Image").get_single_value<Color>()), maximum_result);
102 }
103
104 Result &standard_deviation_result = this->get_result("Standard Deviation");
105 if (standard_deviation_result.should_compute()) {
106 standard_deviation_result.allocate_single_value();
107 standard_deviation_result.set_single_value(0.0f);
108 }
109
110 Result &mean_result = this->get_result("Mean");
111 if (!mean_result.should_compute()) {
112 return;
113 }
114
115 mean_result.allocate_single_value();
116 this->set_output(float4(this->get_input("Image").get_single_value<Color>()), mean_result);
117 }
118
120 {
121 const Result &input = this->get_input("Image");
122 return sum_color(this->context(), input) / math::reduce_mul(input.domain().data_size);
123 }
124
126 {
127 const Result &input = this->get_input("Image");
128 const float4 sum_of_squared_difference_to_mean = sum_squared_difference_color(
129 this->context(), input, mean);
130 const float4 mean_squared_difference_to_mean = sum_of_squared_difference_to_mean /
132 return math::sqrt(mean_squared_difference_to_mean);
133 }
134
135 void set_output(const float4 value, Result &output)
136 {
137 switch (this->get_channel()) {
139 output.set_single_value(value.x);
140 return;
142 output.set_single_value(value.y);
143 return;
145 output.set_single_value(value.z);
146 return;
148 output.set_single_value(math::dot(value.xyz(), float3(luminance_coefficients_bt709_)));
149 return;
151 float luminance_coefficients[3];
153 output.set_single_value(math::dot(value.xyz(), float3(luminance_coefficients)));
154 return;
155 }
156 }
157 }
158
160 {
162 this->get_input("Channel").get_single_value_default<MenuValue>().value);
163 }
164};
165
167{
168 return new LevelsOperation(context, node);
169}
170
171static void node_register()
172{
173 static bke::bNodeType ntype;
174
175 cmp_node_type_base(&ntype, "CompositorNodeLevels"_ustr, CMP_NODE_VIEW_LEVELS);
176 ntype.ui_name = "Levels";
177 ntype.ui_description = "Compute average and standard deviation of pixel values";
178 ntype.enum_name_legacy = "LEVELS";
180 ntype.declare = node_declare;
181 ntype.flag |= NODE_PREVIEW;
183
185}
187
188} // namespace blender::nodes::node_composite_levels_cc
#define NODE_CLASS_CONVERTER
Definition BKE_node.hh:484
#define CMP_NODE_VIEW_LEVELS
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define output
NodeOperation(Context &context, const bNode &node)
Result & get_result(StringRef identifier)
Definition operation.cc:40
Context & context() const
Definition operation.cc:57
Result & get_input(StringRef identifier) const
Definition operation.cc:35
bool should_compute() const
Definition result.cc:1124
void set_single_value(const T &value)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
float4 sum_squared_difference_color(Context &context, const Result &input, const float4 subtrahend)
Color minimum_color(Context &context, const Result &input)
ColorSceneLinear4f< eAlpha::Premultiplied > Color
Definition COM_result.hh:96
Color maximum_color(Context &context, const Result &input)
float4 sum_color(Context &context, const Result &input)
T sqrt(const T &a)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
T reduce_mul(const VecBase< T, Size > &a)
static void node_declare(NodeDeclarationBuilder &b)
static const EnumPropertyItem channel_items[]
static NodeOperation * get_compositor_operation(Context &context, const bNode &node)
BLI_INLINE void IMB_colormanagement_get_luminance_coefficients(float r_rgb[3])
@ CMP_NODE_LEVLES_LUMINANCE
@ CMP_NODE_LEVLES_LUMINANCE_BT709
@ CMP_NODE_LEVLES_GREEN
void cmp_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
Defines a node type.
Definition BKE_node.hh:265
std::string ui_description
Definition BKE_node.hh:271
NodeGetCompositorOperationFunction get_compositor_operation
Definition BKE_node.hh:379
const char * enum_name_legacy
Definition BKE_node.hh:274
NodeDeclareFunction declare
Definition BKE_node.hh:393
#define N_(msgid)