Rerun C++ SDK
Loading...
Searching...
No Matches
segmentation_image.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/segmentation_image.fbs".
3
4#pragma once
5
6#include "../collection.hpp"
7#include "../component_batch.hpp"
8#include "../component_column.hpp"
9#include "../components/draw_order.hpp"
10#include "../components/image_buffer.hpp"
11#include "../components/image_format.hpp"
12#include "../components/opacity.hpp"
13#include "../image_utils.hpp"
14#include "../indicator_component.hpp"
15#include "../result.hpp"
16
17#include <cstdint>
18#include <optional>
19#include <utility>
20#include <vector>
21
22namespace rerun::archetypes {
23 /// **Archetype**: An image made up of integer `components::ClassId`s.
24 ///
25 /// Each pixel corresponds to a `components::ClassId` that will be mapped to a color based on `archetypes::AnnotationContext`.
26 ///
27 /// In the case of floating point images, the label will be looked up based on rounding to the nearest
28 /// integer value.
29 ///
30 /// Use `archetypes::AnnotationContext` to associate each class with a color and a label.
31 ///
32 /// Since the underlying `rerun::datatypes::TensorData` uses `rerun::Collection` internally,
33 /// data can be passed in without a copy from raw pointers or by reference from `std::vector`/`std::array`/c-arrays.
34 /// If needed, this "borrow-behavior" can be extended by defining your own `rerun::CollectionAdapter`.
35 ///
36 /// ## Example
37 ///
38 /// ### Simple segmentation image
39 /// ![image](https://static.rerun.io/segmentation_image_simple/f8aac62abcf4c59c5d62f9ebc2d86fd0285c1736/full.png)
40 ///
41 /// ```cpp
42 /// #include <rerun.hpp>
43 ///
44 /// #include <algorithm> // std::fill_n
45 /// #include <vector>
46 ///
47 /// int main() {
48 /// const auto rec = rerun::RecordingStream("rerun_example_segmentation_image");
49 /// rec.spawn().exit_on_failure();
50 ///
51 /// // Create a segmentation image
52 /// const int HEIGHT = 8;
53 /// const int WIDTH = 12;
54 /// std::vector<uint8_t> data(WIDTH * HEIGHT, 0);
55 /// for (auto y = 0; y <4; ++y) { // top half
56 /// std::fill_n(data.begin() + y * WIDTH, 6, static_cast<uint8_t>(1)); // left half
57 /// }
58 /// for (auto y = 4; y <8; ++y) { // bottom half
59 /// std::fill_n(data.begin() + y * WIDTH + 6, 6, static_cast<uint8_t>(2)); // right half
60 /// }
61 ///
62 /// // create an annotation context to describe the classes
63 /// rec.log_static(
64 /// "/",
65 /// rerun::AnnotationContext({
66 /// rerun::AnnotationInfo(1, "red", rerun::Rgba32(255, 0, 0)),
67 /// rerun::AnnotationInfo(2, "green", rerun::Rgba32(0, 255, 0)),
68 /// })
69 /// );
70 ///
71 /// rec.log("image", rerun::SegmentationImage(data.data(), {WIDTH, HEIGHT}));
72 /// }
73 /// ```
75 /// The raw image data.
76 std::optional<ComponentBatch> buffer;
77
78 /// The format of the image.
79 std::optional<ComponentBatch> format;
80
81 /// Opacity of the image, useful for layering the segmentation image on top of another image.
82 ///
83 /// Defaults to 0.5 if there's any other images in the scene, otherwise 1.0.
84 std::optional<ComponentBatch> opacity;
85
86 /// An optional floating point value that specifies the 2D drawing order.
87 ///
88 /// Objects with higher values are drawn on top of those with lower values.
89 /// Defaults to `0.0`.
90 std::optional<ComponentBatch> draw_order;
91
92 public:
93 static constexpr const char IndicatorComponentName[] =
94 "rerun.components.SegmentationImageIndicator";
95
96 /// Indicator component, used to identify the archetype when converting to a list of components.
98 /// The name of the archetype as used in `ComponentDescriptor`s.
99 static constexpr const char ArchetypeName[] = "rerun.archetypes.SegmentationImage";
100
101 /// `ComponentDescriptor` for the `buffer` field.
102 static constexpr auto Descriptor_buffer = ComponentDescriptor(
103 ArchetypeName, "buffer",
105 );
106 /// `ComponentDescriptor` for the `format` field.
107 static constexpr auto Descriptor_format = ComponentDescriptor(
108 ArchetypeName, "format",
110 );
111 /// `ComponentDescriptor` for the `opacity` field.
113 ArchetypeName, "opacity",
115 );
116 /// `ComponentDescriptor` for the `draw_order` field.
118 ArchetypeName, "draw_order",
120 );
121
122 public: // START of extensions from segmentation_image_ext.cpp:
123 /// Constructs image from pointer + resolution, inferring the datatype from the pointer type.
124 ///
125 /// @param pixels The raw image data.
126 /// ⚠️ Does not take ownership of the data, the caller must ensure the data outlives the image.
127 /// The number of elements is assumed to be `W * H`.
128 /// @param resolution The resolution of the image as {width, height}.
129 template <typename TElement>
130 SegmentationImage(const TElement* pixels, WidthHeight resolution)
132 reinterpret_cast<const uint8_t*>(pixels), resolution, get_datatype(pixels)} {}
133
134 /// Constructs image from pixel data + resolution with datatype inferred from the passed collection.
135 ///
136 /// @param pixels The raw image data.
137 /// If the data does not outlive the image, use `std::move` or create the `rerun::Collection`
138 /// explicitly ahead of time with `rerun::Collection::take_ownership`.
139 /// The length of the data should be `W * H`.
140 /// @param resolution The resolution of the image as {width, height}.
141 template <typename TElement>
143 : SegmentationImage{pixels.to_uint8(), resolution, get_datatype(pixels.data())} {}
144
145 /// Constructs image from pixel data + resolution with explicit datatype. Borrows data from a pointer (i.e. data must outlive the image!).
146 ///
147 /// @param bytes The raw image data.
148 /// ⚠️ Does not take ownership of the data, the caller must ensure the data outlives the image.
149 /// The byte size of the data is assumed to be `W * H * datatype.size`
150 /// @param resolution The resolution of the image as {width, height}.
151 /// @param datatype How the data should be interpreted.
153 const void* bytes, WidthHeight resolution, datatypes::ChannelDatatype datatype
154 )
156 Collection<uint8_t>::borrow(bytes, num_bytes(resolution, datatype)),
157 resolution,
158 datatype} {}
159
160 /// Constructs image from pixel data + resolution + datatype.
161 ///
162 /// @param bytes The raw image data as bytes.
163 /// If the data does not outlive the image, use `std::move` or create the `rerun::Collection`
164 /// explicitly ahead of time with `rerun::Collection::take_ownership`.
165 /// The length of the data should be `W * H`.
166 /// @param resolution The resolution of the image as {width, height}.
167 /// @param datatype How the data should be interpreted.
170 ) {
171 auto image_format = datatypes::ImageFormat{resolution, datatype};
172 if (bytes.size() != image_format.num_bytes()) {
173 Error(
174 ErrorCode::InvalidTensorDimension,
175 "SegmentationImage buffer has the wrong size. Got " +
176 std::to_string(bytes.size()) + " bytes, expected " +
177 std::to_string(image_format.num_bytes())
178 )
179 .handle();
180 }
181 *this = std::move(*this).with_buffer(bytes).with_format(image_format);
182 }
183
184 // END of extensions from segmentation_image_ext.cpp, start of generated code:
185
186 public:
187 SegmentationImage() = default;
188 SegmentationImage(SegmentationImage&& other) = default;
189 SegmentationImage(const SegmentationImage& other) = default;
190 SegmentationImage& operator=(const SegmentationImage& other) = default;
191 SegmentationImage& operator=(SegmentationImage&& other) = default;
192
193 /// Update only some specific fields of a `SegmentationImage`.
195 return SegmentationImage();
196 }
197
198 /// Clear all the fields of a `SegmentationImage`.
200
201 /// The raw image data.
203 buffer = ComponentBatch::from_loggable(_buffer, Descriptor_buffer).value_or_throw();
204 return std::move(*this);
205 }
206
207 /// This method makes it possible to pack multiple `buffer` in a single component batch.
208 ///
209 /// This only makes sense when used in conjunction with `columns`. `with_buffer` should
210 /// be used when logging a single row's worth of data.
212 ) && {
213 buffer = ComponentBatch::from_loggable(_buffer, Descriptor_buffer).value_or_throw();
214 return std::move(*this);
215 }
216
217 /// The format of the image.
219 format = ComponentBatch::from_loggable(_format, Descriptor_format).value_or_throw();
220 return std::move(*this);
221 }
222
223 /// This method makes it possible to pack multiple `format` in a single component batch.
224 ///
225 /// This only makes sense when used in conjunction with `columns`. `with_format` should
226 /// be used when logging a single row's worth of data.
228 ) && {
229 format = ComponentBatch::from_loggable(_format, Descriptor_format).value_or_throw();
230 return std::move(*this);
231 }
232
233 /// Opacity of the image, useful for layering the segmentation image on top of another image.
234 ///
235 /// Defaults to 0.5 if there's any other images in the scene, otherwise 1.0.
237 opacity = ComponentBatch::from_loggable(_opacity, Descriptor_opacity).value_or_throw();
238 return std::move(*this);
239 }
240
241 /// This method makes it possible to pack multiple `opacity` in a single component batch.
242 ///
243 /// This only makes sense when used in conjunction with `columns`. `with_opacity` should
244 /// be used when logging a single row's worth of data.
246 ) && {
247 opacity = ComponentBatch::from_loggable(_opacity, Descriptor_opacity).value_or_throw();
248 return std::move(*this);
249 }
250
251 /// An optional floating point value that specifies the 2D drawing order.
252 ///
253 /// Objects with higher values are drawn on top of those with lower values.
254 /// Defaults to `0.0`.
256 draw_order =
257 ComponentBatch::from_loggable(_draw_order, Descriptor_draw_order).value_or_throw();
258 return std::move(*this);
259 }
260
261 /// This method makes it possible to pack multiple `draw_order` in a single component batch.
262 ///
263 /// This only makes sense when used in conjunction with `columns`. `with_draw_order` should
264 /// be used when logging a single row's worth of data.
267 ) && {
268 draw_order =
269 ComponentBatch::from_loggable(_draw_order, Descriptor_draw_order).value_or_throw();
270 return std::move(*this);
271 }
272
273 /// Partitions the component data into multiple sub-batches.
274 ///
275 /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
276 /// instead, via `ComponentBatch::partitioned`.
277 ///
278 /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
279 ///
280 /// The specified `lengths` must sum to the total length of the component batch.
282
283 /// Partitions the component data into unit-length sub-batches.
284 ///
285 /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
286 /// where `n` is automatically guessed.
288 };
289
290} // namespace rerun::archetypes
291
292namespace rerun {
293 /// \private
294 template <typename T>
295 struct AsComponents;
296
297 /// \private
298 template <>
299 struct AsComponents<archetypes::SegmentationImage> {
300 /// Serialize all set component batches.
301 static Result<Collection<ComponentBatch>> as_batches(
302 const archetypes::SegmentationImage& archetype
303 );
304 };
305} // namespace rerun
Generic collection of elements that are roughly contiguous in memory.
Definition collection.hpp:49
size_t size() const
Returns the number of instances in this collection.
Definition collection.hpp:291
Status outcome object (success or error) returned for fallible operations.
Definition error.hpp:99
void handle() const
Handle this error based on the set log handler.
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
ChannelDatatype
Datatype: The innermost datatype of an image.
Definition channel_datatype.hpp:27
All Rerun C++ types and functions are in the rerun namespace or one of its nested namespaces.
Definition rerun.hpp:23
Collection< TElement > borrow(const TElement *data, size_t num_instances=1)
Borrows binary data into a Collection from a pointer.
Definition collection.hpp:462
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
The width and height of an image.
Definition image_utils.hpp:13
Archetype: An image made up of integer components::ClassIds.
Definition segmentation_image.hpp:74
SegmentationImage with_many_buffer(const Collection< rerun::components::ImageBuffer > &_buffer) &&
This method makes it possible to pack multiple buffer in a single component batch.
Definition segmentation_image.hpp:211
Collection< ComponentColumn > columns()
Partitions the component data into unit-length sub-batches.
std::optional< ComponentBatch > opacity
Opacity of the image, useful for layering the segmentation image on top of another image.
Definition segmentation_image.hpp:84
SegmentationImage with_buffer(const rerun::components::ImageBuffer &_buffer) &&
The raw image data.
Definition segmentation_image.hpp:202
SegmentationImage with_many_format(const Collection< rerun::components::ImageFormat > &_format) &&
This method makes it possible to pack multiple format in a single component batch.
Definition segmentation_image.hpp:227
Collection< ComponentColumn > columns(const Collection< uint32_t > &lengths_)
Partitions the component data into multiple sub-batches.
SegmentationImage(Collection< uint8_t > bytes, WidthHeight resolution, datatypes::ChannelDatatype datatype)
Constructs image from pixel data + resolution + datatype.
Definition segmentation_image.hpp:168
std::optional< ComponentBatch > buffer
The raw image data.
Definition segmentation_image.hpp:76
SegmentationImage with_draw_order(const rerun::components::DrawOrder &_draw_order) &&
An optional floating point value that specifies the 2D drawing order.
Definition segmentation_image.hpp:255
static SegmentationImage clear_fields()
Clear all the fields of a SegmentationImage.
std::optional< ComponentBatch > draw_order
An optional floating point value that specifies the 2D drawing order.
Definition segmentation_image.hpp:90
static constexpr auto Descriptor_buffer
ComponentDescriptor for the buffer field.
Definition segmentation_image.hpp:102
SegmentationImage(Collection< TElement > pixels, WidthHeight resolution)
Constructs image from pixel data + resolution with datatype inferred from the passed collection.
Definition segmentation_image.hpp:142
static constexpr auto Descriptor_format
ComponentDescriptor for the format field.
Definition segmentation_image.hpp:107
static constexpr auto Descriptor_opacity
ComponentDescriptor for the opacity field.
Definition segmentation_image.hpp:112
SegmentationImage(const TElement *pixels, WidthHeight resolution)
Constructs image from pointer + resolution, inferring the datatype from the pointer type.
Definition segmentation_image.hpp:130
SegmentationImage with_many_opacity(const Collection< rerun::components::Opacity > &_opacity) &&
This method makes it possible to pack multiple opacity in a single component batch.
Definition segmentation_image.hpp:245
std::optional< ComponentBatch > format
The format of the image.
Definition segmentation_image.hpp:79
SegmentationImage 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 segmentation_image.hpp:265
SegmentationImage(const void *bytes, WidthHeight resolution, datatypes::ChannelDatatype datatype)
Constructs image from pixel data + resolution with explicit datatype.
Definition segmentation_image.hpp:152
static constexpr auto Descriptor_draw_order
ComponentDescriptor for the draw_order field.
Definition segmentation_image.hpp:117
static constexpr const char ArchetypeName[]
The name of the archetype as used in ComponentDescriptors.
Definition segmentation_image.hpp:99
static SegmentationImage update_fields()
Update only some specific fields of a SegmentationImage.
Definition segmentation_image.hpp:194
SegmentationImage with_opacity(const rerun::components::Opacity &_opacity) &&
Opacity of the image, useful for layering the segmentation image on top of another image.
Definition segmentation_image.hpp:236
SegmentationImage with_format(const rerun::components::ImageFormat &_format) &&
The format of the image.
Definition segmentation_image.hpp:218
Component: Draw order of 2D elements.
Definition draw_order.hpp:20
Component: A buffer that is known to store image data.
Definition image_buffer.hpp:19
Component: The metadata describing the contents of a components::ImageBuffer.
Definition image_format.hpp:15
Indicator component used by archetypes when converting them to component lists.
Definition indicator_component.hpp:32
Component: Degree of transparency ranging from 0.0 (fully transparent) to 1.0 (fully opaque).
Definition opacity.hpp:18
Datatype: The metadata describing the contents of a components::ImageBuffer.
Definition image_format.hpp:25