Blender V5.3
node_geo_field_variance.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2025 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
6
7#include "BLI_array.hh"
10
11#include "NOD_rna_define.hh"
13
14#include "RNA_enum_types.hh"
15
16#include "node_geometry_util.hh"
17
19#include "UI_resources.hh"
20
21#include <numeric>
22
24
26{
27 const bNode *node = b.node_or_null();
28
29 if (node != nullptr) {
30 const eCustomDataType data_type = eCustomDataType(node->custom1);
31 b.add_input(data_type, "Value"_ustr)
32 .structure_type(StructureType::Field)
33 .description("The values the standard deviation and variance will be calculated from");
34 }
35
36 b.add_input<decl::Int>("Group ID"_ustr, "Group Index"_ustr)
37 .structure_type(StructureType::Field)
38 .hide_value()
39 .description("An index used to group values together for multiple separate operations");
40
41 if (node != nullptr) {
42 const eCustomDataType data_type = eCustomDataType(node->custom1);
43 b.add_output(data_type, "Standard Deviation"_ustr)
44 .structure_type(StructureType::Field)
45 .propagate_references()
46 .description("The square root of the variance for each group");
47 b.add_output(data_type, "Variance"_ustr)
48 .structure_type(StructureType::Field)
49 .propagate_references()
50 .description("The expected squared deviation from the mean for each group");
51 }
52}
53
54static void node_layout(ui::Layout &layout, bContext * /*C*/, PointerRNA *ptr)
55{
56 layout.prop(ptr, "data_type", UI_ITEM_NONE, "", ICON_NONE);
57 layout.prop(ptr, "domain", UI_ITEM_NONE, "", ICON_NONE);
58}
59
60static void node_init(bNodeTree * /*tree*/, bNode *node)
61{
62 node->custom1 = CD_PROP_FLOAT;
63 node->custom2 = int16_t(AttrDomain::Point);
64}
65
66enum class Operation { StdDev = 0, Variance = 1 };
67
68static std::optional<eCustomDataType> node_type_from_other_socket(const bNodeSocket &socket)
69{
70 switch (socket.type) {
71 case SOCK_FLOAT:
72 case SOCK_BOOLEAN:
73 case SOCK_INT:
74 return CD_PROP_FLOAT;
75 case SOCK_VECTOR:
76 case SOCK_RGBA:
77 return CD_PROP_FLOAT3;
78 default:
79 return std::nullopt;
80 }
81}
82
84{
85 const NodeDeclaration &declaration = *params.node_type().static_declaration;
86 search_link_ops_for_declarations(params, declaration.inputs);
87
88 const std::optional<eCustomDataType> type = node_type_from_other_socket(params.other_socket());
89 if (!type) {
90 return;
91 }
92 if (params.in_out() == SOCK_OUT) {
93 params.add_item(
94 IFACE_("Standard Deviation"),
95 [type](LinkSearchOpParams &params) {
96 bNode &node = params.add_node("GeometryNodeFieldVariance"_ustr);
97 node.custom1 = *type;
98 params.update_and_connect_available_socket(node, "Standard Deviation"_ustr);
99 },
100 0);
101 params.add_item(
102 IFACE_("Variance"),
103 [type](LinkSearchOpParams &params) {
104 bNode &node = params.add_node("GeometryNodeFieldVariance"_ustr);
105 node.custom1 = *type;
106 params.update_and_connect_available_socket(node, "Variance"_ustr);
107 },
108 -1);
109 }
110 else {
111 params.add_item(
112 IFACE_("Value"),
113 [type](LinkSearchOpParams &params) {
114 bNode &node = params.add_node("GeometryNodeFieldVariance"_ustr);
115 node.custom1 = *type;
116 params.update_and_connect_available_socket(node, "Value"_ustr);
117 },
118 0);
119 }
120}
121
123 private:
124 GField input_;
125 Field<int> group_index_;
126 AttrDomain source_domain_;
127 Operation operation_;
128
129 public:
130 FieldVarianceInput(const AttrDomain source_domain,
131 GField input,
132 Field<int> group_index,
133 Operation operation)
134 : bke::GeometryFieldInput(input.cpp_type(), "Calculation"),
135 input_(std::move(input)),
136 group_index_(std::move(group_index)),
137 source_domain_(source_domain),
138 operation_(operation)
139 {
140 }
141
143 const IndexMask & /*mask*/) const final
144 {
145 const AttributeAccessor attributes = *context.attributes();
146 const int64_t domain_size = attributes.domain_size(source_domain_);
147 if (domain_size == 0) {
148 return {};
149 }
150
151 const bke::GeometryFieldContext source_context{context, source_domain_};
152 fn::FieldEvaluator evaluator{source_context, domain_size};
153 evaluator.add(input_);
154 evaluator.add(group_index_);
155 evaluator.evaluate();
156 const GVArray g_values = evaluator.get_evaluated(0);
157 const VArray<int> group_indices = evaluator.get_evaluated<int>(1);
158
159 GVArray g_outputs;
160
161 g_values.type().to_static_type<int, float, float3>([&]<typename T>() {
162 const VArraySpan<T> values = g_values.typed<T>();
163
164 if (operation_ == Operation::StdDev) {
165 if (group_indices.is_single()) {
166 const T mean = std::reduce(values.begin(), values.end(), T()) / domain_size;
167 const T sum_of_squared_diffs = std::accumulate(
168 values.begin(), values.end(), T(), [mean](T accumulator, const T &value) {
169 T difference = mean - value;
170 return accumulator + difference * difference;
171 });
172 g_outputs = VArray<T>::from_single(math::sqrt(sum_of_squared_diffs / domain_size),
173 domain_size);
174 }
175 else {
176 Map<int, std::pair<T, int>> sum_and_counts;
177 Map<int, T> deviations;
178
179 for (const int i : values.index_range()) {
180 auto &pair = sum_and_counts.lookup_or_add(group_indices[i], std::make_pair(T(), 0));
181 pair.first = pair.first + values[i];
182 pair.second = pair.second + 1;
183 }
184
185 for (const int i : values.index_range()) {
186 const auto &pair = sum_and_counts.lookup(group_indices[i]);
187 T mean = pair.first / pair.second;
188 T deviation = (mean - values[i]);
189 deviation = deviation * deviation;
190
191 T &dev_sum = deviations.lookup_or_add(group_indices[i], T());
192 dev_sum = dev_sum + deviation;
193 }
194
195 Array<T> outputs(domain_size);
196 for (const int i : values.index_range()) {
197 const auto &pair = sum_and_counts.lookup(group_indices[i]);
198 outputs[i] = math::sqrt(deviations.lookup(group_indices[i]) / pair.second);
199 }
200 g_outputs = VArray<T>::from_container(std::move(outputs));
201 }
202 }
203 else {
204 if (group_indices.is_single()) {
205 const T mean = std::reduce(values.begin(), values.end(), T()) / domain_size;
206 const T sum_of_squared_diffs = std::accumulate(
207 values.begin(), values.end(), T(), [mean](T accumulator, const T &value) {
208 T difference = mean - value;
209 return accumulator + difference * difference;
210 });
211 g_outputs = VArray<T>::from_single(sum_of_squared_diffs / domain_size, domain_size);
212 }
213 else {
214 Map<int, std::pair<T, int>> sum_and_counts;
215 Map<int, T> deviations;
216
217 for (const int i : values.index_range()) {
218 auto &pair = sum_and_counts.lookup_or_add(group_indices[i], std::make_pair(T(), 0));
219 pair.first = pair.first + values[i];
220 pair.second = pair.second + 1;
221 }
222
223 for (const int i : values.index_range()) {
224 const auto &pair = sum_and_counts.lookup(group_indices[i]);
225 T mean = pair.first / pair.second;
226 T deviation = (mean - values[i]);
227 deviation = deviation * deviation;
228
229 T &dev_sum = deviations.lookup_or_add(group_indices[i], T());
230 dev_sum = dev_sum + deviation;
231 }
232
233 Array<T> outputs(domain_size);
234 for (const int i : values.index_range()) {
235 const auto &pair = sum_and_counts.lookup(group_indices[i]);
236 outputs[i] = deviations.lookup(group_indices[i]) / pair.second;
237 }
238 g_outputs = VArray<T>::from_container(std::move(outputs));
239 }
240 }
241 });
242
243 return attributes.adapt_domain(std::move(g_outputs), source_domain_, context.domain());
244 }
245
246 void foreach_recursive_field(FunctionRef<void(const GField &)> fn) const final
247 {
248 fn(input_);
249 fn(group_index_);
250 }
251
252 void hash_unique(UniqueHashBytes &hash, fn::FieldHashDeep &deep_hash_cache) const override
253 {
254 static constexpr int8_t id = 0;
255 hash.add(&id);
256 hash.add(deep_hash_cache.ensure(input_));
257 hash.add(deep_hash_cache.ensure(group_index_));
258 hash.add(source_domain_);
259 hash.add(operation_);
260 }
261
262 std::optional<AttrDomain> preferred_domain(
263 const GeometryComponent & /*component*/) const override
264 {
265 return source_domain_;
266 }
267};
268
270{
271 const AttrDomain source_domain = AttrDomain(params.node().custom2);
272
273 const Field<int> group_index_field = params.extract_input<Field<int>>("Group Index"_ustr);
274 const GField input_field = params.extract_input<GField>("Value"_ustr);
275 if (params.output_is_required("Standard Deviation"_ustr)) {
276 params.set_output<GField>(
277 "Standard Deviation"_ustr,
279 source_domain, input_field, group_index_field, Operation::StdDev));
280 }
281 if (params.output_is_required("Variance"_ustr)) {
282 params.set_output<GField>(
283 "Variance"_ustr,
285 source_domain, input_field, group_index_field, Operation::Variance));
286 }
287}
288
289static void node_rna(StructRNA *srna)
290{
291 static EnumPropertyItem items[] = {
292 {CD_PROP_FLOAT, "FLOAT", ICON_NODE_SOCKET_FLOAT, "Float", "Floating-point value"},
294 "FLOAT_VECTOR",
295 ICON_NODE_SOCKET_VECTOR,
296 "Vector",
297 "3D vector with floating-point values"},
298 {0, nullptr, 0, nullptr, nullptr},
299 };
300
302 "data_type",
303 "Data Type",
304 "Type of data the outputs are calculated from",
305 items,
308
310 "domain",
311 "Domain",
312 "",
315 int(AttrDomain::Point),
316 nullptr,
317 true);
318}
319
320static void node_register()
321{
322 static bke::bNodeType ntype;
323
324 geo_node_type_base(&ntype, "GeometryNodeFieldVariance"_ustr);
325 ntype.ui_name = "Field Variance";
326 ntype.ui_description = "Calculate the standard deviation and variance of a given field";
329 ntype.initfunc = node_init;
331 ntype.declare = node_declare;
334 node_rna(ntype.rna_ext.srna);
335}
337
338} // namespace blender::nodes::node_geo_field_variance_cc
#define NODE_CLASS_CONVERTER
Definition BKE_node.hh:484
#define final(a, b, c)
Definition BLI_hash_c.hh:21
#define IFACE_(msgid)
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define NOD_inline_enum_accessors(member)
#define UI_ITEM_NONE
void to_static_type(Fn &&fn) const
const Value & lookup(const Key &key) const
Definition BLI_map.hh:545
Value & lookup_or_add(const Key &key, const Value &value)
Definition BLI_map.hh:588
static VArray from_single(T value, const int64_t size)
static VArray from_container(ContainerT container)
GVArray adapt_domain(const GVArray &varray, const AttrDomain from_domain, const AttrDomain to_domain) const
int domain_size(const AttrDomain domain) const
constexpr const T * begin() const
constexpr IndexRange index_range() const
constexpr const T * end() const
int add(GField field, GVArray *varray_ptr)
const GVArray & get_evaluated(const int field_index) const
uint64_t hash() const
Definition field.cc:185
const CPPType & cpp_type() const
Definition FN_field.hh:559
static GField from_input(Args &&...args)
Definition FN_field.hh:482
const bke::bNodeType & node_type() const
void add_item(std::string socket_name, SocketLinkOperation::LinkSocketFn fn, int weight=0)
T extract_input(const UString identifier)
bool output_is_required(const UString identifier) const
void set_output(const UString identifier, T &&value)
void update_and_connect_available_socket(bNode &new_node, UString socket_name)
Vector< SocketDeclaration * > inputs
void foreach_recursive_field(FunctionRef< void(const GField &)> fn) const final
void hash_unique(UniqueHashBytes &hash, fn::FieldHashDeep &deep_hash_cache) const override
std::optional< AttrDomain > preferred_domain(const GeometryComponent &) const override
FieldVarianceInput(const AttrDomain source_domain, GField input, Field< int > group_index, Operation operation)
GVArray get_varray_for_context(const bke::GeometryFieldContext &context, const IndexMask &) const final
#define T
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
T sqrt(const T &a)
static void node_init(bNodeTree *, bNode *node)
static void node_declare(NodeDeclarationBuilder &b)
static void node_layout(ui::Layout &layout, bContext *, PointerRNA *ptr)
static void node_geo_exec(GeoNodeExecParams params)
static std::optional< eCustomDataType > node_type_from_other_socket(const bNodeSocket &socket)
static void node_gather_link_searches(GatherLinkSearchOpParams &params)
void search_link_ops_for_declarations(GatherLinkSearchOpParams &params, Span< SocketDeclaration * > declarations)
PropertyRNA * RNA_def_node_enum(StructRNA *srna, const char *identifier, const char *ui_name, const char *ui_description, const EnumPropertyItem *static_items, const EnumRNAAccessors accessors, std::optional< int > default_value, const EnumPropertyItemFunc item_func, const bool allow_animation)
__int64 int64_t
Definition BKE_text.h:90
VecBase< float, 3 > float3
void geo_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
const EnumPropertyItem rna_enum_attribute_domain_items[]
signed char int8_t
Definition BKE_text.h:76
signed short int16_t
Definition BKE_text.h:77
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
eNodeSocketDatatype type
Defines a node type.
Definition BKE_node.hh:265
void(*) draw_buttons(ui::Layout &, bContext *C, PointerRNA *ptr)
Definition BKE_node.hh:290
std::string ui_description
Definition BKE_node.hh:271
NodeGeometryExecFunction geometry_node_execute
Definition BKE_node.hh:385
void(*) initfunc(bNodeTree *ntree, bNode *node)
Definition BKE_node.hh:320
NodeGatherSocketLinkOperationsFunction gather_link_search_ops
Definition BKE_node.hh:409
NodeDeclareFunction declare
Definition BKE_node.hh:393
nodes::NodeDeclaration * static_declaration
Definition BKE_node.hh:402
UniqueHash ensure(const GFieldRef &field)
Definition field.cc:113
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)