Rerun C++ SDK
Loading...
Searching...
No Matches
boxes2d.hpp
1// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
2// Based on "crates/store/re_types/definitions/rerun/archetypes/boxes2d.fbs".
3
4#pragma once
5
6#include "../collection.hpp"
7#include "../component_batch.hpp"
8#include "../component_column.hpp"
9#include "../components/class_id.hpp"
10#include "../components/color.hpp"
11#include "../components/draw_order.hpp"
12#include "../components/half_size2d.hpp"
13#include "../components/position2d.hpp"
14#include "../components/radius.hpp"
15#include "../components/show_labels.hpp"
16#include "../components/text.hpp"
17#include "../indicator_component.hpp"
18#include "../result.hpp"
19
20#include <cstdint>
21#include <optional>
22#include <utility>
23#include <vector>
24
25namespace rerun::archetypes {
26 /// **Archetype**: 2D boxes with half-extents and optional center, colors etc.
27 ///
28 /// ## Example
29 ///
30 /// ### Simple 2D boxes
31 /// ![image](https://static.rerun.io/box2d_simple/ac4424f3cf747382867649610cbd749c45b2020b/full.png)
32 ///
33 /// ```cpp
34 /// #include <rerun.hpp>
35 ///
36 /// int main() {
37 /// const auto rec = rerun::RecordingStream("rerun_example_box2d");
38 /// rec.spawn().exit_on_failure();
39 ///
40 /// rec.log("simple", rerun::Boxes2D::from_mins_and_sizes({{-1.f, -1.f}}, {{2.f, 2.f}}));
41 /// }
42 /// ```
43 struct Boxes2D {
44 /// All half-extents that make up the batch of boxes.
45 std::optional<ComponentBatch> half_sizes;
46
47 /// Optional center positions of the boxes.
48 std::optional<ComponentBatch> centers;
49
50 /// Optional colors for the boxes.
51 std::optional<ComponentBatch> colors;
52
53 /// Optional radii for the lines that make up the boxes.
54 std::optional<ComponentBatch> radii;
55
56 /// Optional text labels for the boxes.
57 ///
58 /// If there's a single label present, it will be placed at the center of the entity.
59 /// Otherwise, each instance will have its own label.
60 std::optional<ComponentBatch> labels;
61
62 /// Optional choice of whether the text labels should be shown by default.
63 std::optional<ComponentBatch> show_labels;
64
65 /// An optional floating point value that specifies the 2D drawing order.
66 ///
67 /// Objects with higher values are drawn on top of those with lower values.
68 /// Defaults to `10.0`.
69 std::optional<ComponentBatch> draw_order;
70
71 /// Optional `components::ClassId`s for the boxes.
72 ///
73 /// The `components::ClassId` provides colors and labels if not specified explicitly.
74 std::optional<ComponentBatch> class_ids;
75
76 public:
77 static constexpr const char IndicatorComponentName[] = "rerun.components.Boxes2DIndicator";
78
79 /// Indicator component, used to identify the archetype when converting to a list of components.
81 /// The name of the archetype as used in `ComponentDescriptor`s.
82 static constexpr const char ArchetypeName[] = "rerun.archetypes.Boxes2D";
83
84 /// `ComponentDescriptor` for the `half_sizes` field.
86 ArchetypeName, "half_sizes",
88 );
89 /// `ComponentDescriptor` for the `centers` field.
90 static constexpr auto Descriptor_centers = ComponentDescriptor(
91 ArchetypeName, "centers",
93 );
94 /// `ComponentDescriptor` for the `colors` field.
95 static constexpr auto Descriptor_colors = ComponentDescriptor(
97 );
98 /// `ComponentDescriptor` for the `radii` field.
99 static constexpr auto Descriptor_radii = ComponentDescriptor(
101 );
102 /// `ComponentDescriptor` for the `labels` field.
103 static constexpr auto Descriptor_labels = ComponentDescriptor(
105 );
106 /// `ComponentDescriptor` for the `show_labels` field.
108 ArchetypeName, "show_labels",
110 );
111 /// `ComponentDescriptor` for the `draw_order` field.
113 ArchetypeName, "draw_order",
115 );
116 /// `ComponentDescriptor` for the `class_ids` field.
118 ArchetypeName, "class_ids",
120 );
121
122 public: // START of extensions from boxes2d_ext.cpp:
123 /// Creates new `Boxes2D` with `half_sizes` centered around the local origin.
125 return Boxes2D().with_half_sizes(std::move(half_sizes));
126 }
127
128 /// Creates new `Boxes2D` with `centers` and `half_sizes`.
132 ) {
133 return Boxes2D()
134 .with_half_sizes(std::move(half_sizes))
135 .with_centers(std::move(centers));
136 }
137
138 /// Creates new `Boxes2D` with `half_sizes` created from (full) sizes.
139 ///
140 /// TODO(#3285): Does *not* preserve data as-is and instead creates half-sizes from the
141 /// input data.
142 static Boxes2D from_sizes(const std::vector<datatypes::Vec2D>& sizes);
143
144 /// Creates new `Boxes2D` with `centers` and `half_sizes` created from centers and (full)
145 /// sizes.
146 ///
147 /// TODO(#3285): Does *not* preserve data as-is and instead creates centers and half-sizes
148 /// from the input data.
150 Collection<components::Position2D> centers, const std::vector<datatypes::Vec2D>& sizes
151 ) {
152 return from_sizes(std::move(sizes)).with_centers(std::move(centers));
153 }
154
155 /// Creates new `Boxes2D` with `half_sizes` and `centers` created from minimums and (full)
156 /// sizes.
157 ///
158 /// TODO(#3285): Does *not* preserve data as-is and instead creates centers and half-sizes
159 /// from the input data.
161 const std::vector<datatypes::Vec2D>& mins, const std::vector<datatypes::Vec2D>& sizes
162 );
163
164 // END of extensions from boxes2d_ext.cpp, start of generated code:
165
166 public:
167 Boxes2D() = default;
168 Boxes2D(Boxes2D&& other) = default;
169 Boxes2D(const Boxes2D& other) = default;
170 Boxes2D& operator=(const Boxes2D& other) = default;
171 Boxes2D& operator=(Boxes2D&& other) = default;
172
173 /// Update only some specific fields of a `Boxes2D`.
175 return Boxes2D();
176 }
177
178 /// Clear all the fields of a `Boxes2D`.
180
181 /// All half-extents that make up the batch of boxes.
183 half_sizes =
184 ComponentBatch::from_loggable(_half_sizes, Descriptor_half_sizes).value_or_throw();
185 return std::move(*this);
186 }
187
188 /// Optional center positions of the boxes.
190 centers = ComponentBatch::from_loggable(_centers, Descriptor_centers).value_or_throw();
191 return std::move(*this);
192 }
193
194 /// Optional colors for the boxes.
196 colors = ComponentBatch::from_loggable(_colors, Descriptor_colors).value_or_throw();
197 return std::move(*this);
198 }
199
200 /// Optional radii for the lines that make up the boxes.
202 radii = ComponentBatch::from_loggable(_radii, Descriptor_radii).value_or_throw();
203 return std::move(*this);
204 }
205
206 /// Optional text labels for the boxes.
207 ///
208 /// If there's a single label present, it will be placed at the center of the entity.
209 /// Otherwise, each instance will have its own label.
211 labels = ComponentBatch::from_loggable(_labels, Descriptor_labels).value_or_throw();
212 return std::move(*this);
213 }
214
215 /// Optional choice of whether the text labels should be shown by default.
218 .value_or_throw();
219 return std::move(*this);
220 }
221
222 /// This method makes it possible to pack multiple `show_labels` in a single component batch.
223 ///
224 /// This only makes sense when used in conjunction with `columns`. `with_show_labels` should
225 /// be used when logging a single row's worth of data.
227 ) && {
229 .value_or_throw();
230 return std::move(*this);
231 }
232
233 /// An optional floating point value that specifies the 2D drawing order.
234 ///
235 /// Objects with higher values are drawn on top of those with lower values.
236 /// Defaults to `10.0`.
238 draw_order =
239 ComponentBatch::from_loggable(_draw_order, Descriptor_draw_order).value_or_throw();
240 return std::move(*this);
241 }
242
243 /// This method makes it possible to pack multiple `draw_order` in a single component batch.
244 ///
245 /// This only makes sense when used in conjunction with `columns`. `with_draw_order` should
246 /// be used when logging a single row's worth of data.
248 ) && {
249 draw_order =
250 ComponentBatch::from_loggable(_draw_order, Descriptor_draw_order).value_or_throw();
251 return std::move(*this);
252 }
253
254 /// Optional `components::ClassId`s for the boxes.
255 ///
256 /// The `components::ClassId` provides colors and labels if not specified explicitly.
258 class_ids =
259 ComponentBatch::from_loggable(_class_ids, Descriptor_class_ids).value_or_throw();
260 return std::move(*this);
261 }
262
263 /// Partitions the component data into multiple sub-batches.
264 ///
265 /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
266 /// instead, via `ComponentBatch::partitioned`.
267 ///
268 /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
269 ///
270 /// The specified `lengths` must sum to the total length of the component batch.
272
273 /// Partitions the component data into unit-length sub-batches.
274 ///
275 /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
276 /// where `n` is automatically guessed.
278 };
279
280} // namespace rerun::archetypes
281
282namespace rerun {
283 /// \private
284 template <typename T>
285 struct AsComponents;
286
287 /// \private
288 template <>
289 struct AsComponents<archetypes::Boxes2D> {
290 /// Serialize all set component batches.
291 static Result<Collection<ComponentBatch>> as_batches(const archetypes::Boxes2D& archetype);
292 };
293} // namespace rerun
Generic collection of elements that are roughly contiguous in memory.
Definition collection.hpp:49
A class for representing either a usable value, or an error.
Definition result.hpp:14
All built-in archetypes. See Types in the Rerun manual.
Definition rerun.hpp:76
All Rerun C++ types and functions are in the rerun namespace or one of its nested namespaces.
Definition rerun.hpp:23
static Result< ComponentBatch > from_loggable(const rerun::Collection< T > &components, const ComponentDescriptor &descriptor)
Creates a new component batch from a collection of component instances.
Definition component_batch.hpp:46
A ComponentDescriptor fully describes the semantics of a column of data.
Definition component_descriptor.hpp:14
The Loggable trait is used by all built-in implementation of rerun::AsComponents to serialize a colle...
Definition loggable.hpp:11
Archetype: 2D boxes with half-extents and optional center, colors etc.
Definition boxes2d.hpp:43
static Boxes2D clear_fields()
Clear all the fields of a Boxes2D.
Boxes2D with_class_ids(const Collection< rerun::components::ClassId > &_class_ids) &&
Optional components::ClassIds for the boxes.
Definition boxes2d.hpp:257
static constexpr auto Descriptor_show_labels
ComponentDescriptor for the show_labels field.
Definition boxes2d.hpp:107
std::optional< ComponentBatch > centers
Optional center positions of the boxes.
Definition boxes2d.hpp:48
static Boxes2D update_fields()
Update only some specific fields of a Boxes2D.
Definition boxes2d.hpp:174
std::optional< ComponentBatch > draw_order
An optional floating point value that specifies the 2D drawing order.
Definition boxes2d.hpp:69
std::optional< ComponentBatch > show_labels
Optional choice of whether the text labels should be shown by default.
Definition boxes2d.hpp:63
Boxes2D with_draw_order(const rerun::components::DrawOrder &_draw_order) &&
An optional floating point value that specifies the 2D drawing order.
Definition boxes2d.hpp:237
std::optional< ComponentBatch > radii
Optional radii for the lines that make up the boxes.
Definition boxes2d.hpp:54
std::optional< ComponentBatch > half_sizes
All half-extents that make up the batch of boxes.
Definition boxes2d.hpp:45
Boxes2D with_labels(const Collection< rerun::components::Text > &_labels) &&
Optional text labels for the boxes.
Definition boxes2d.hpp:210
Boxes2D with_colors(const Collection< rerun::components::Color > &_colors) &&
Optional colors for the boxes.
Definition boxes2d.hpp:195
static constexpr const char ArchetypeName[]
The name of the archetype as used in ComponentDescriptors.
Definition boxes2d.hpp:82
Collection< ComponentColumn > columns()
Partitions the component data into unit-length sub-batches.
Boxes2D with_half_sizes(const Collection< rerun::components::HalfSize2D > &_half_sizes) &&
All half-extents that make up the batch of boxes.
Definition boxes2d.hpp:182
static constexpr auto Descriptor_class_ids
ComponentDescriptor for the class_ids field.
Definition boxes2d.hpp:117
static constexpr auto Descriptor_radii
ComponentDescriptor for the radii field.
Definition boxes2d.hpp:99
static constexpr auto Descriptor_colors
ComponentDescriptor for the colors field.
Definition boxes2d.hpp:95
Boxes2D with_centers(const Collection< rerun::components::Position2D > &_centers) &&
Optional center positions of the boxes.
Definition boxes2d.hpp:189
static constexpr auto Descriptor_draw_order
ComponentDescriptor for the draw_order field.
Definition boxes2d.hpp:112
static Boxes2D from_centers_and_sizes(Collection< components::Position2D > centers, const std::vector< datatypes::Vec2D > &sizes)
Creates new Boxes2D with centers and half_sizes created from centers and (full) sizes.
Definition boxes2d.hpp:149
Collection< ComponentColumn > columns(const Collection< uint32_t > &lengths_)
Partitions the component data into multiple sub-batches.
Boxes2D with_many_show_labels(const Collection< rerun::components::ShowLabels > &_show_labels) &&
This method makes it possible to pack multiple show_labels in a single component batch.
Definition boxes2d.hpp:226
static Boxes2D from_sizes(const std::vector< datatypes::Vec2D > &sizes)
Creates new Boxes2D with half_sizes created from (full) sizes.
static Boxes2D from_centers_and_half_sizes(Collection< components::Position2D > centers, Collection< components::HalfSize2D > half_sizes)
Creates new Boxes2D with centers and half_sizes.
Definition boxes2d.hpp:129
static constexpr auto Descriptor_labels
ComponentDescriptor for the labels field.
Definition boxes2d.hpp:103
static constexpr auto Descriptor_half_sizes
ComponentDescriptor for the half_sizes field.
Definition boxes2d.hpp:85
Boxes2D with_many_draw_order(const Collection< rerun::components::DrawOrder > &_draw_order) &&
This method makes it possible to pack multiple draw_order in a single component batch.
Definition boxes2d.hpp:247
std::optional< ComponentBatch > labels
Optional text labels for the boxes.
Definition boxes2d.hpp:60
std::optional< ComponentBatch > colors
Optional colors for the boxes.
Definition boxes2d.hpp:51
Boxes2D with_radii(const Collection< rerun::components::Radius > &_radii) &&
Optional radii for the lines that make up the boxes.
Definition boxes2d.hpp:201
static constexpr auto Descriptor_centers
ComponentDescriptor for the centers field.
Definition boxes2d.hpp:90
static Boxes2D from_half_sizes(Collection< components::HalfSize2D > half_sizes)
Creates new Boxes2D with half_sizes centered around the local origin.
Definition boxes2d.hpp:124
static Boxes2D from_mins_and_sizes(const std::vector< datatypes::Vec2D > &mins, const std::vector< datatypes::Vec2D > &sizes)
Creates new Boxes2D with half_sizes and centers created from minimums and (full) sizes.
Boxes2D with_show_labels(const rerun::components::ShowLabels &_show_labels) &&
Optional choice of whether the text labels should be shown by default.
Definition boxes2d.hpp:216
std::optional< ComponentBatch > class_ids
Optional components::ClassIds for the boxes.
Definition boxes2d.hpp:74
Component: Draw order of 2D elements.
Definition draw_order.hpp:20
Indicator component used by archetypes when converting them to component lists.
Definition indicator_component.hpp:32
Component: Whether the entity's components::Text label is shown.
Definition show_labels.hpp:19