Blender V5.3
node_geo_attribute_statistic.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include <algorithm>
6#include <numeric>
7
8#include "NOD_rna_define.hh"
9
11#include "UI_resources.hh"
12
13#include "BLI_array_utils.hh"
14
16
17#include "RNA_enum_types.hh"
18
19#include "node_geometry_util.hh"
20
22
24{
25 const bNode *node = b.node_or_null();
26
27 b.add_input<decl::Geometry>("Geometry"_ustr).description("Geometry to get the statistics from");
28 b.add_input<decl::Bool>("Selection"_ustr)
29 .default_value(true)
30 .evaluated_geometry_field()
31 .hide_value();
32
33 if (node != nullptr) {
34 const eCustomDataType data_type = eCustomDataType(node->custom1);
35 b.add_input(data_type, "Attribute"_ustr).hide_value().evaluated_geometry_field();
36
37 b.add_output(data_type, "Mean"_ustr);
38 b.add_output(data_type, CTX_N_(BLT_I18NCONTEXT_ID_NODETREE, "Median"_ustr))
39 .translation_context(BLT_I18NCONTEXT_ID_NODETREE);
40 b.add_output(data_type, "Sum"_ustr);
41 b.add_output(data_type, "Min"_ustr);
42 b.add_output(data_type, "Max"_ustr);
43 b.add_output(data_type, "Range"_ustr);
44 b.add_output(data_type, "Standard Deviation"_ustr);
45 b.add_output(data_type, "Variance"_ustr);
46 }
47}
48
49static void node_layout(ui::Layout &layout, bContext * /*C*/, PointerRNA *ptr)
50{
51 layout.prop(ptr, "data_type", UI_ITEM_NONE, "", ICON_NONE);
52 layout.prop(ptr, "domain", UI_ITEM_NONE, "", ICON_NONE);
53}
54
55static void node_init(bNodeTree * /*tree*/, bNode *node)
56{
57 node->custom1 = CD_PROP_FLOAT;
58 node->custom2 = int16_t(AttrDomain::Point);
59}
60
61static std::optional<eCustomDataType> node_type_from_other_socket(const bNodeSocket &socket)
62{
63 switch (socket.type) {
64 case SOCK_FLOAT:
65 case SOCK_BOOLEAN:
66 case SOCK_INT:
67 return CD_PROP_FLOAT;
68 case SOCK_VECTOR:
69 case SOCK_RGBA:
70 case SOCK_ROTATION:
71 return CD_PROP_FLOAT3;
72 default:
73 return {};
74 }
75}
76
78{
79 const bke::bNodeType &node_type = params.node_type();
80 const NodeDeclaration &declaration = *params.node_type().static_declaration;
81 search_link_ops_for_declarations(params, declaration.inputs);
82
83 const std::optional<eCustomDataType> type = node_type_from_other_socket(params.other_socket());
84 if (!type) {
85 return;
86 }
87
88 if (params.in_out() == SOCK_IN) {
89 params.add_item(IFACE_("Attribute"), [node_type, type](LinkSearchOpParams &params) {
90 bNode &node = params.add_node(node_type);
91 node.custom1 = *type;
92 params.update_and_connect_available_socket(node, "Attribute"_ustr);
93 });
94 }
95 else {
96 for (const UString name : {"Mean"_ustr,
97 "Median"_ustr,
98 "Sum"_ustr,
99 "Min"_ustr,
100 "Max"_ustr,
101 "Range"_ustr,
102 "Standard Deviation"_ustr,
103 "Variance"_ustr})
104 {
105 params.add_item(IFACE_(name.ref()), [node_type, name, type](LinkSearchOpParams &params) {
106 bNode &node = params.add_node(node_type);
107 node.custom1 = *type;
108 params.update_and_connect_available_socket(node, name);
109 });
110 }
111 }
112}
113
114static float compute_variance(const Span<float> data, const float mean)
115{
116 if (data.size() <= 1) {
117 return 0.0f;
118 }
119
120 float sum_of_squared_differences = std::accumulate(
121 data.begin(), data.end(), 0.0f, [mean](float accumulator, float value) {
122 float difference = mean - value;
123 return accumulator + difference * difference;
124 });
125
126 return sum_of_squared_differences / data.size();
127}
128
130{
131 if (data.is_empty()) {
132 return 0.0f;
133 }
134
135 const float median = data[data.size() / 2];
136
137 /* For spans of even length, the median is the average of the middle two elements. */
138 if (data.size() % 2 == 0) {
139 return (median + data[data.size() / 2 - 1]) * 0.5f;
140 }
141 return median;
142}
143
145{
146 GeometrySet geometry_set = params.extract_input<GeometrySet>("Geometry"_ustr);
147 const bNode &node = params.node();
148 const eCustomDataType data_type = eCustomDataType(node.custom1);
149 const AttrDomain domain = AttrDomain(node.custom2);
150 Vector<const GeometryComponent *> components = geometry_set.get_components();
151
152 const Field<bool> selection_field = params.extract_input<Field<bool>>("Selection"_ustr);
153
154 switch (data_type) {
155 case CD_PROP_FLOAT: {
156 const Field<float> input_field = params.extract_input<Field<float>>("Attribute"_ustr);
158 for (const GeometryComponent *component : components) {
159 const int domain_size = component->attribute_domain_size(domain);
160 if (domain_size == 0) {
161 continue;
162 }
163 const bke::GeometryFieldContext field_context{*component, domain};
164 fn::FieldEvaluator data_evaluator{field_context, domain_size};
165 data_evaluator.add(input_field);
166 data_evaluator.set_selection(selection_field);
167 data_evaluator.evaluate();
168 const VArray<float> component_data = data_evaluator.get_evaluated<float>(0);
169 const IndexMask selection = data_evaluator.get_evaluated_selection_as_mask();
170
171 const int next_data_index = data.size();
172 data.resize(next_data_index + selection.size());
173 MutableSpan<float> selected_data = data.as_mutable_span().slice(next_data_index,
174 selection.size());
175 array_utils::gather(component_data, selection, selected_data);
176 }
177
178 float mean = 0.0f;
179 float median = 0.0f;
180 float sum = 0.0f;
181 float min = 0.0f;
182 float max = 0.0f;
183 float range = 0.0f;
184 float standard_deviation = 0.0f;
185 float variance = 0.0f;
186 const bool sort_required = params.output_is_required("Min"_ustr) ||
187 params.output_is_required("Max"_ustr) ||
188 params.output_is_required("Range"_ustr) ||
189 params.output_is_required("Median"_ustr);
190 const bool sum_required = params.output_is_required("Sum"_ustr) ||
191 params.output_is_required("Mean"_ustr);
192 const bool variance_required = params.output_is_required("Standard Deviation"_ustr) ||
193 params.output_is_required("Variance"_ustr);
194
195 if (data.size() != 0) {
196 if (sort_required) {
197 std::ranges::sort(data);
198 median = median_of_sorted_span(data);
199
200 min = data.first();
201 max = data.last();
202 range = max - min;
203 }
204 if (sum_required || variance_required) {
206 mean = sum / data.size();
207
208 if (variance_required) {
209 variance = compute_variance(data, mean);
210 standard_deviation = std::sqrt(variance);
211 }
212 }
213 }
214
215 if (sum_required) {
216 params.set_output("Sum"_ustr, sum);
217 params.set_output("Mean"_ustr, mean);
218 }
219 if (sort_required) {
220 params.set_output("Min"_ustr, min);
221 params.set_output("Max"_ustr, max);
222 params.set_output("Range"_ustr, range);
223 params.set_output("Median"_ustr, median);
224 }
225 if (variance_required) {
226 params.set_output("Standard Deviation"_ustr, standard_deviation);
227 params.set_output("Variance"_ustr, variance);
228 }
229 break;
230 }
231 case CD_PROP_FLOAT3: {
232 const Field<float3> input_field = params.extract_input<Field<float3>>("Attribute"_ustr);
234 for (const GeometryComponent *component : components) {
235 const std::optional<AttributeAccessor> attributes = component->attributes();
236 if (!attributes.has_value()) {
237 continue;
238 }
239 if (attributes->domain_supported(domain)) {
240 const bke::GeometryFieldContext field_context{*component, domain};
241 fn::FieldEvaluator data_evaluator{field_context, attributes->domain_size(domain)};
242 data_evaluator.add(input_field);
243 data_evaluator.set_selection(selection_field);
244 data_evaluator.evaluate();
245 const VArray<float3> component_data = data_evaluator.get_evaluated<float3>(0);
246 const IndexMask selection = data_evaluator.get_evaluated_selection_as_mask();
247
248 const int next_data_index = data.size();
249 data.resize(data.size() + selection.size());
250 MutableSpan<float3> selected_data = data.as_mutable_span().slice(next_data_index,
251 selection.size());
252 array_utils::gather(component_data, selection, selected_data);
253 }
254 }
255
256 float3 median{0};
257 float3 min{0};
258 float3 max{0};
259 float3 range{0};
260 float3 sum{0};
261 float3 mean{0};
262 float3 variance{0};
263 float3 standard_deviation{0};
264 const bool sort_required = params.output_is_required("Min"_ustr) ||
265 params.output_is_required("Max"_ustr) ||
266 params.output_is_required("Range"_ustr) ||
267 params.output_is_required("Median"_ustr);
268 const bool sum_required = params.output_is_required("Sum"_ustr) ||
269 params.output_is_required("Mean"_ustr);
270 const bool variance_required = params.output_is_required("Standard Deviation"_ustr) ||
271 params.output_is_required("Variance"_ustr);
272
273 Array<float> data_x;
274 Array<float> data_y;
275 Array<float> data_z;
276 if (sort_required || variance_required) {
277 data_x.reinitialize(data.size());
278 data_y.reinitialize(data.size());
279 data_z.reinitialize(data.size());
280 for (const int i : data.index_range()) {
281 data_x[i] = data[i].x;
282 data_y[i] = data[i].y;
283 data_z[i] = data[i].z;
284 }
285 }
286
287 if (data.size() != 0) {
288 if (sort_required) {
289 std::ranges::sort(data_x);
290 std::ranges::sort(data_y);
291 std::ranges::sort(data_z);
292
293 const float x_median = median_of_sorted_span(data_x);
294 const float y_median = median_of_sorted_span(data_y);
295 const float z_median = median_of_sorted_span(data_z);
296 median = float3(x_median, y_median, z_median);
297
298 min = float3(data_x.first(), data_y.first(), data_z.first());
299 max = float3(data_x.last(), data_y.last(), data_z.last());
300 range = max - min;
301 }
302 if (sum_required || variance_required) {
303 sum = array_utils::compute_sum(data.as_span());
304 mean = sum / data.size();
305
306 if (variance_required) {
307 const float x_variance = compute_variance(data_x, mean.x);
308 const float y_variance = compute_variance(data_y, mean.y);
309 const float z_variance = compute_variance(data_z, mean.z);
310 variance = float3(x_variance, y_variance, z_variance);
311 standard_deviation = float3(
312 std::sqrt(variance.x), std::sqrt(variance.y), std::sqrt(variance.z));
313 }
314 }
315 }
316
317 if (sum_required) {
318 params.set_output("Sum"_ustr, sum);
319 params.set_output("Mean"_ustr, mean);
320 }
321 if (sort_required) {
322 params.set_output("Min"_ustr, min);
323 params.set_output("Max"_ustr, max);
324 params.set_output("Range"_ustr, range);
325 params.set_output("Median"_ustr, median);
326 }
327 if (variance_required) {
328 params.set_output("Standard Deviation"_ustr, standard_deviation);
329 params.set_output("Variance"_ustr, variance);
330 }
331 break;
332 }
333 default:
334 break;
335 }
336}
337
338static void node_rna(StructRNA *srna)
339{
341 srna,
342 "data_type",
343 "Data Type",
344 "The data type the attribute is converted to before calculating the results",
348 [](bContext * /*C*/, PointerRNA * /*ptr*/, PropertyRNA * /*prop*/, bool *r_free) {
349 *r_free = true;
351 return ELEM(item.value, CD_PROP_FLOAT, CD_PROP_FLOAT3);
352 });
353 });
354
356 "domain",
357 "Domain",
358 "Which domain to read the data from",
361 int(AttrDomain::Point),
362 nullptr,
363 true);
364}
365
366static void node_register()
367{
368 static bke::bNodeType ntype;
369 geo_node_type_base(&ntype, "GeometryNodeAttributeStatistic"_ustr, GEO_NODE_ATTRIBUTE_STATISTIC);
370 ntype.ui_name = "Attribute Statistic";
371 ntype.ui_description =
372 "Calculate statistics about a data set from a field evaluated on a geometry";
373 ntype.enum_name_legacy = "ATTRIBUTE_STATISTIC";
375 ntype.initfunc = node_init;
376 ntype.declare = node_declare;
381
382 node_rna(ntype.rna_ext.srna);
383}
385
386} // namespace blender::nodes::node_geo_attribute_statistic_cc
#define NODE_CLASS_ATTRIBUTE
Definition BKE_node.hh:493
#define GEO_NODE_ATTRIBUTE_STATISTIC
#define CTX_N_(context, msgid)
#define BLT_I18NCONTEXT_ID_NODETREE
#define IFACE_(msgid)
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define NOD_inline_enum_accessors(member)
#define UI_ITEM_NONE
#define ELEM(...)
btScalar max
const T & last(const int64_t n=0) const
Definition BLI_array.hh:307
const T & first() const
Definition BLI_array.hh:292
void reinitialize(const int64_t new_size)
Definition BLI_array.hh:430
void set_selection(Field< bool > selection)
int add(GField field, GVArray *varray_ptr)
IndexMask get_evaluated_selection_as_mask() const
const GVArray & get_evaluated(const int field_index) const
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 gather(const GVArray &src, const IndexMask &indices, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
T compute_sum(const Span< T > data)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
static float median_of_sorted_span(const Span< float > data)
static std::optional< eCustomDataType > node_type_from_other_socket(const bNodeSocket &socket)
static float compute_variance(const Span< float > data, const float mean)
static void node_gather_link_searches(GatherLinkSearchOpParams &params)
static void node_layout(ui::Layout &layout, bContext *, PointerRNA *ptr)
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)
const EnumPropertyItem * enum_items_filter(const EnumPropertyItem *original_item_array, FunctionRef< bool(const EnumPropertyItem &item)> fn)
BMesh const char void * data
const EnumPropertyItem rna_enum_attribute_type_items[]
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 short int16_t
Definition BKE_text.h:77
#define min(a, b)
Definition sort.cc:38
eNodeSocketDatatype type
Vector< const GeometryComponent * > get_components() const
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
const char * enum_name_legacy
Definition BKE_node.hh:274
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
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)