Create Rust version of the "Loggable Data Types" doc section

docs/code-examples/Cargo.toml

@@ -1,14 +1,116 @@
 [package]
 name = "code_examples"
-version = "0.7.0-alpha.0"
-edition = "2021"
-rust-version = "1.69"
-license = "MIT OR Apache-2.0"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
 publish = false
 
+
+[[bin]]
+name = 'annotation_context_connections'
+path = 'annotation_context_connections.rs'
+
+[[bin]]
+name = 'annotation_context_rects'
+path = 'annotation_context_rects.rs'
+
+[[bin]]
+name = 'annotation_context_segmentation'
+path = 'annotation_context_segmentation.rs'
+
+[[bin]]
+name = 'arrow3d_simple'
+path = 'arrow3d_simple.rs'
+
+[[bin]]
+name = 'box3d_simple'
+path = 'box3d_simple.rs'
+
+[[bin]]
+name = 'depth_image_3d'
+path = 'depth_image_3d.rs'
+
+[[bin]]
+name = 'depth_image_simple'
+path = 'depth_image_simple.rs'
+
+[[bin]]
+name = 'image_simple'
+path = 'image_simple.rs'
+
+[[bin]]
+name = 'line_segments2d_simple'
+path = 'line_segments2d_simple.rs'
+
+[[bin]]
+name = 'line_segments3d_simple'
+path = 'line_segments3d_simple.rs'
+
+[[bin]]
+name = 'line_strip2d_simple'
+path = 'line_strip2d_simple.rs'
+
+[[bin]]
+name = 'line_strip3d_simple'
+path = 'line_strip3d_simple.rs'
+
+[[bin]]
+name = 'mesh_simple'
+path = 'mesh_simple.rs'
+
+[[bin]]
+name = 'pinhole_simple'
+path = 'pinhole_simple.rs'
+
 [[bin]]
 name = 'point2d_simple'
 path = 'point2d_simple.rs'
 
+[[bin]]
+name = 'point2d_random'
+path = 'point2d_random.rs'
+
+[[bin]]
+name = 'point3d_random'
+path = 'point3d_random.rs'
+
+[[bin]]
+name = 'point3d_simple'
+path = 'point3d_simple.rs'
+
+[[bin]]
+name = 'rect2d_simple'
+path = 'rect2d_simple.rs'
+
+[[bin]]
+name = 'scalar_simple'
+path = 'scalar_simple.rs'
+
+[[bin]]
+name = 'segmentation_image_simple'
+path = 'segmentation_image_simple.rs'
+
+[[bin]]
+name = 'tensor_one_dim'
+path = 'tensor_one_dim.rs'
+
+[[bin]]
+name = 'tensor_simple'
+path = 'tensor_simple.rs'
+
+[[bin]]
+name = 'text_entry_simple'
+path = 'text_entry_simple.rs'
+
+[[bin]]
+name = 'transform3d_simple'
+path = 'transform3d_simple.rs'
+
+
 [dependencies]
+ahash.workspace = true
+ndarray.workspace = true
+rand = "0.8"
+rand_distr = "0.4.3"
 rerun = { path = "../../crates/rerun", features = ["native_viewer"] }

docs/code-examples/annotation_context_connections.rs

@@ -0,0 +1,82 @@
+//! Log some very simple points.
+use rerun::components::{
+    AnnotationContext, AnnotationInfo, ClassDescription, ClassId, ColorRGBA, KeypointId, Label,
+    Point3D,
+};
+use rerun::{MsgSender, RecordingStreamBuilder};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (rec_stream, storage) =
+        RecordingStreamBuilder::new("annotation_context_connections").memory()?;
+
+    // Log an annotation context to assign a label and color to each class
+    // Create a class description with labels and color for each keypoint ID as well as some
+    // connections between keypoints.
+    let mut class_desc = ClassDescription::default();
+    class_desc.keypoint_map.insert(
+        KeypointId(0),
+        AnnotationInfo {
+            id: 0,
+            label: Some(Label("zero".to_owned())),
+            color: Some(ColorRGBA::from_rgb(255, 0, 0)),
+        },
+    );
+    class_desc.keypoint_map.insert(
+        KeypointId(1),
+        AnnotationInfo {
+            id: 1,
+            label: Some(Label("one".to_owned())),
+            color: Some(ColorRGBA::from_rgb(0, 255, 0)),
+        },
+    );
+    class_desc.keypoint_map.insert(
+        KeypointId(2),
+        AnnotationInfo {
+            id: 2,
+            label: Some(Label("two".to_owned())),
+            color: Some(ColorRGBA::from_rgb(0, 0, 255)),
+        },
+    );
+    class_desc.keypoint_map.insert(
+        KeypointId(3),
+        AnnotationInfo {
+            id: 3,
+            label: Some(Label("three".to_owned())),
+            color: Some(ColorRGBA::from_rgb(255, 255, 0)),
+        },
+    );
+    class_desc.keypoint_connections = [(0, 2), (1, 2), (2, 3)]
+        .into_iter()
+        .map(|(a, b)| (KeypointId(a), KeypointId(b)))
+        .collect();
+
+    let mut annotation = AnnotationContext::default();
+    annotation.class_map.insert(ClassId(0), class_desc);
+
+    MsgSender::new("/")
+        .with_component(&[annotation])?
+        .send(&rec_stream)?;
+
+    // Log some points with different keypoint IDs
+    let points = [
+        [0., 0., 0.],
+        [50., 0., 20.],
+        [100., 100., 30.],
+        [0., 50., 40.],
+    ]
+    .into_iter()
+    .map(Point3D::from)
+    .collect::<Vec<_>>();
+
+    MsgSender::new("points")
+        .with_component(&points)?
+        .with_component(&[KeypointId(0), KeypointId(1), KeypointId(2), KeypointId(3)])?
+        .with_splat(ClassId(0))?
+        .send(&rec_stream)?;
+
+    rec_stream.flush_blocking();
+
+    rerun::native_viewer::show(storage.take())?;
+
+    Ok(())
+}

docs/code-examples/annotation_context_rects.rs

@@ -0,0 +1,56 @@
+//! Log rectangles with different colors and labels.
+use rerun::components::{
+    AnnotationContext, AnnotationInfo, ClassDescription, ClassId, ColorRGBA, Label, Rect2D, Vec4D,
+};
+use rerun::{MsgSender, RecordingStreamBuilder};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (rec_stream, storage) = RecordingStreamBuilder::new("annotation_context_rects").memory()?;
+
+    // Log an annotation context to assign a label and color to each class
+    let mut annotation = AnnotationContext::default();
+    annotation.class_map.insert(
+        ClassId(1),
+        ClassDescription {
+            info: AnnotationInfo {
+                id: 1,
+                label: Some(Label("red".to_owned())),
+                color: Some(ColorRGBA::from_rgb(255, 0, 0)),
+            },
+            ..Default::default()
+        },
+    );
+    annotation.class_map.insert(
+        ClassId(2),
+        ClassDescription {
+            info: AnnotationInfo {
+                id: 2,
+                label: Some(Label("green".to_owned())),
+                color: Some(ColorRGBA::from_rgb(0, 255, 0)),
+            },
+            ..Default::default()
+        },
+    );
+
+    MsgSender::new("/")
+        .with_component(&[annotation])?
+        .send(&rec_stream)?;
+
+    // Log a batch of 2 rectangles with different class IDs
+    MsgSender::new("detections")
+        .with_component(&[
+            Rect2D::XYWH(Vec4D([-2., -2., 3., 3.])),
+            Rect2D::XYWH(Vec4D([0., 0., 2., 2.])),
+        ])?
+        .with_component(&[ClassId(1), ClassId(2)])?
+        .send(&rec_stream)?;
+
+    // Log an extra rect to set the view bounds
+    MsgSender::new("bounds")
+        .with_component(&[Rect2D::XCYCWH(Vec4D([0.0, 0.0, 5.0, 5.0]))])?
+        .send(&rec_stream)?;
+
+    rec_stream.flush_blocking();
+    rerun::native_viewer::show(storage.take())?;
+    Ok(())
+}

docs/code-examples/annotation_context_segmentation.rs

@@ -0,0 +1,58 @@
+//! Log a segmentation image with annotations.
+use ndarray::{s, Array, ShapeBuilder};
+use rerun::components::{
+    AnnotationContext, AnnotationInfo, ClassDescription, ClassId, ColorRGBA, Label, Tensor,
+    TensorDataMeaning,
+};
+use rerun::{MsgSender, RecordingStreamBuilder};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (rec_stream, storage) =
+        RecordingStreamBuilder::new("annotation_context_segmentation").memory()?;
+
+    // create a segmentation image
+    let mut data = Array::<u8, _>::zeros((200, 300).f());
+    data.slice_mut(s![50..150, 50..120]).fill(1);
+    data.slice_mut(s![100..180, 130..280]).fill(2);
+
+    let mut image = Tensor::try_from(data.as_standard_layout().view())?;
+    image.meaning = TensorDataMeaning::ClassId;
+
+    // create an annotation context to describe the classes
+    let mut annotation = AnnotationContext::default();
+    annotation.class_map.insert(
+        ClassId(1),
+        ClassDescription {
+            info: AnnotationInfo {
+                id: 1,
+                label: Some(Label("red".to_owned())),
+                color: Some(ColorRGBA::from_rgb(255, 0, 0)),
+            },
+            ..Default::default()
+        },
+    );
+    annotation.class_map.insert(
+        ClassId(2),
+        ClassDescription {
+            info: AnnotationInfo {
+                id: 2,
+                label: Some(Label("green".to_owned())),
+                color: Some(ColorRGBA::from_rgb(0, 255, 0)),
+            },
+            ..Default::default()
+        },
+    );
+
+    // log the annotation and the image
+    MsgSender::new("segmentation")
+        .with_component(&[annotation])?
+        .send(&rec_stream)?;
+
+    MsgSender::new("segmentation/image")
+        .with_component(&[image])?
+        .send(&rec_stream)?;
+
+    rec_stream.flush_blocking();
+    rerun::native_viewer::show(storage.take())?;
+    Ok(())
+}

docs/code-examples/arrow3d_simple.rs

@@ -0,0 +1,21 @@
+//! Log a single arrow
+use rerun::components::{Arrow3D, Radius, Vec3D};
+use rerun::{MsgSender, RecordingStreamBuilder};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (rec_stream, storage) = RecordingStreamBuilder::new("arrow").memory()?;
+
+    let arrow = Arrow3D {
+        origin: Vec3D::from([0.0, 0.0, 0.0]),
+        vector: Vec3D::from([1.0, 0.0, 1.0]),
+    };
+
+    MsgSender::new("arrow")
+        .with_component(&[arrow])?
+        .with_component(&[Radius(0.05)])?
+        .send(&rec_stream)?;
+
+    rec_stream.flush_blocking();
+    rerun::native_viewer::show(storage.take())?;
+    Ok(())
+}

docs/code-examples/box3d_simple.rs

@@ -0,0 +1,15 @@
+//! Log some a single oriented bounding box
+use rerun::components::Box3D;
+use rerun::{MsgSender, RecordingStreamBuilder};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (rec_stream, storage) = RecordingStreamBuilder::new("box3d").memory()?;
+
+    MsgSender::new("simple")
+        .with_component(&[Box3D::new(2.0, 2.0, 1.0)])?
+        .send(&rec_stream)?;
+
+    rec_stream.flush_blocking();
+    rerun::native_viewer::show(storage.take())?;
+    Ok(())
+}