New DepthImage archetype (#6915)

### What
* Part of #6386

This changes `DepthImage` from a tensor to a byte-blob + resolution +
data-type.
It adds new code for hovering images and uploading images to GPU, both
general enough to also work for color images and segmentation images.
This means those PRs will be a lot smaller.

Since we still need to support color and segmentation images encoded as
tensors, the code is quite complex, with duplicated paths here and
there. It will all get cleaned up in later PRs.

I'm reusing a lot of stuff from tensors, like `TensorMeaning`,
`TensorStats` `TensorElement`, but these will be renamed and improved
before #6386 is done.

### TODO
* [x] Update `depth_image_ext.cpp`
* [x] Update `depth_image_ext.py`
* [x] Fix hovering depth images in 3D view

### Checklist
* [x] I have read and agree to [Contributor
Guide](https://github.com/rerun-io/rerun/blob/main/CONTRIBUTING.md) and
the [Code of
Conduct](https://github.com/rerun-io/rerun/blob/main/CODE_OF_CONDUCT.md)
* [x] I've included a screenshot or gif (if applicable)
* [x] I have tested the web demo (if applicable):
* Using examples from latest `main` build:
[rerun.io/viewer](https://rerun.io/viewer/pr/6915?manifest_url=https://app.rerun.io/version/main/examples_manifest.json)
* Using full set of examples from `nightly` build:
[rerun.io/viewer](https://rerun.io/viewer/pr/6915?manifest_url=https://app.rerun.io/version/nightly/examples_manifest.json)
* [x] The PR title and labels are set such as to maximize their
usefulness for the next release's CHANGELOG
* [x] If applicable, add a new check to the [release
checklist](https://github.com/rerun-io/rerun/blob/main/tests/python/release_checklist)!
* [x] If have noted any breaking changes to the log API in
`CHANGELOG.md` and the migration guide
* [x] Test a few local examples

- [PR Build Summary](https://build.rerun.io/pr/6915)
- [Recent benchmark results](https://build.rerun.io/graphs/crates.html)
- [Wasm size tracking](https://build.rerun.io/graphs/sizes.html)

To run all checks from `main`, comment on the PR with `@rerun-bot
full-check`.

Author: emilk

CHANGELOG.md

@@ -6,7 +6,8 @@
 * `mesh_material: Material` has been renamed to `albedo_factor: AlbedoFactor` [#6841](https://github.com/rerun-io/rerun/pull/6841)
 * 3D transform APIs: Previously, the transform component was represented as one of several variants (an Arrow union, `enum` in Rust) depending on how the transform was expressed. Instead, there are now several components for translation/scale/rotation/matrices that can live side-by-side in the 3D transform archetype.
 * Python: `NV12/YUY2` are now logged with the new `ImageChromaDownsampled`
-* `ImageEncoded`:s `format` parameter has been replaced with `media_type` (MIME)
+* [`ImageEncoded`](https://rerun.io/docs/reference/types/archetypes/image_encoded?speculative-link):s `format` parameter has been replaced with `media_type` (MIME)
+* [`DepthImage`](https://rerun.io/docs/reference/types/archetypes/depth_image) is no longer encoded as a tensor, and expects its shape in `[width, height]` order
 
 🧳 Migration guide: http://rerun.io/docs/reference/migration/migration-0-18?speculative-link
 

CODE_STYLE.md

@@ -215,6 +215,8 @@ Preprocessor directives/macros are usually prefixed with `RR_`
 
 Include what you use: if you use `std::vector`, then include `<vector>` - don't depend on a transitive include.
 
+We prefer the "data, length" parameter order, e.g. `void foo(const void* data, size_t len)` or `void image(const f32* data, Resolution resolution)`.
+
 
 ## Naming
 We prefer `snake_case` to `kebab-case` for most things (e.g. crate names, crate features, …). `snake_case` is a valid identifier in almost any programming language, while `kebab-case` is not. This means one can use the same `snake_case` identifier everywhere, and not think about whether it needs to be written as `snake_case` in some circumstances.

crates/build/re_types_builder/src/codegen/cpp/mod.rs

@@ -181,6 +181,7 @@ impl CppCodeGenerator {
 
         for &obj in &objects_of_kind {
             if let Err(err) = generate_object_files(
+                reporter,
                 objects,
                 &folder_path_sdk,
                 &folder_path_testing,
@@ -225,6 +226,7 @@ impl CppCodeGenerator {
 }
 
 fn generate_object_files(
+    reporter: &Reporter,
     objects: &Objects,
     folder_path_sdk: &Utf8PathBuf,
     folder_path_testing: &Utf8PathBuf,
@@ -242,7 +244,7 @@ fn generate_object_files(
     let (hpp_type_extensions, hpp_extension_string) =
         hpp_type_extensions(folder_path_sdk, &filename_stem, &mut hpp_includes);
 
-    let (hpp, cpp) = generate_hpp_cpp(objects, obj, hpp_includes, &hpp_type_extensions)?;
+    let (hpp, cpp) = generate_hpp_cpp(reporter, objects, obj, hpp_includes, &hpp_type_extensions)?;
 
     for (extension, tokens) in [("hpp", Some(hpp)), ("cpp", cpp)] {
         let Some(tokens) = tokens else {
@@ -351,13 +353,14 @@ fn hpp_type_extensions(
 }
 
 fn generate_hpp_cpp(
+    reporter: &Reporter,
     objects: &Objects,
     obj: &Object,
     hpp_includes: Includes,
     hpp_type_extensions: &TokenStream,
 ) -> Result<(TokenStream, Option<TokenStream>)> {
     let QuotedObject { hpp, cpp } =
-        QuotedObject::new(objects, obj, hpp_includes, hpp_type_extensions)?;
+        QuotedObject::new(reporter, objects, obj, hpp_includes, hpp_type_extensions)?;
     let snake_case_name = obj.snake_case_name();
     let hash = quote! { # };
     let pragma_once = pragma_once();
@@ -392,6 +395,7 @@ struct QuotedObject {
 impl QuotedObject {
     #[allow(clippy::unnecessary_wraps)] // TODO(emilk): implement proper error handling instead of panicking
     pub fn new(
+        reporter: &Reporter,
         objects: &Objects,
         obj: &Object,
         hpp_includes: Includes,
@@ -412,11 +416,16 @@ impl QuotedObject {
                     hpp_type_extensions,
                 )),
                 ObjectKind::View => {
-                    // TODO(#5521): Implement view codegen for Rust.
+                    // TODO(#5521): Implement view codegen for C++.
                     unimplemented!();
                 }
             },
-            ObjectClass::Enum => Ok(Self::from_enum(objects, obj, hpp_includes)),
+            ObjectClass::Enum => {
+                if !hpp_type_extensions.is_empty() {
+                    reporter.error(&obj.virtpath, &obj.fqname, "C++ enums cannot have type extensions, because C++ enums doesn't support member functions");
+                }
+                Ok(Self::from_enum(objects, obj, hpp_includes))
+            }
             ObjectClass::Union => Ok(Self::from_union(
                 objects,
                 obj,

crates/store/re_types/definitions/rerun/archetypes/depth_image.fbs

@@ -25,8 +25,14 @@ table DepthImage (
 ) {
   // --- Required ---
 
-  /// The depth-image data. Should always be a 2-dimensional tensor.
-  data: rerun.components.TensorData ("attr.rerun.component_required", order: 1000);
+  /// The raw depth image data.
+  data: rerun.components.Blob ("attr.rerun.component_required", order: 1000);
+
+  /// The size of the image
+  resolution: rerun.components.Resolution2D ("attr.rerun.component_required", order: 1500);
+
+  /// The data type of the depth image data (U16, F32, …).
+  data_type: rerun.components.ChannelDataType ("attr.rerun.component_required", order: 2000);
 
   // --- Optional ---
 

crates/store/re_types/definitions/rerun/components.fbs

@@ -3,8 +3,10 @@ include "./components/albedo_factor.fbs";
 include "./components/annotation_context.fbs";
 include "./components/axis_length.fbs";
 include "./components/blob.fbs";
+include "./components/channel_data_type.fbs";
 include "./components/class_id.fbs";
 include "./components/clear_is_recursive.fbs";
+include "./components/color_model.fbs";
 include "./components/color.fbs";
 include "./components/colormap.fbs";
 include "./components/depth_meter.fbs";
@@ -31,6 +33,7 @@ include "./components/position3d.fbs";
 include "./components/radius.fbs";
 include "./components/range1d.fbs";
 include "./components/resolution.fbs";
+include "./components/resolution2d.fbs";
 include "./components/rotation3d.fbs";
 include "./components/scalar.fbs";
 include "./components/scale3d.fbs";

crates/store/re_types/definitions/rerun/components/channel_data_type.fbs

@@ -0,0 +1,46 @@
+include "arrow/attributes.fbs";
+include "python/attributes.fbs";
+include "rust/attributes.fbs";
+
+include "rerun/datatypes.fbs";
+include "rerun/attributes.fbs";
+
+namespace rerun.components;
+
+/// The innermost datatype of an image.
+///
+/// How individual color channel components are encoded.
+enum ChannelDataType: byte {
+    /// 8-bit unsigned integer.
+    U8 (default),
+
+    /// 16-bit unsigned integer.
+    U16,
+
+    /// 32-bit unsigned integer.
+    U32,
+
+    /// 64-bit unsigned integer.
+    U64,
+
+    /// 8-bit signed integer.
+    I8,
+
+    /// 16-bit signed integer.
+    I16,
+
+    /// 32-bit signed integer.
+    I32,
+
+    /// 64-bit signed integer.
+    I64,
+
+    /// 16-bit IEEE-754 floating point, also known as `half`.
+    F16,
+
+    /// 32-bit IEEE-754 floating point, also known as `float` or `single`.
+    F32,
+
+    /// 64-bit IEEE-754 floating point, also known as `double`.
+    F64,
+}

crates/store/re_types/definitions/rerun/components/color_model.fbs

@@ -0,0 +1,17 @@
+include "rerun/attributes.fbs";
+
+namespace rerun.components;
+
+/// Specified what color components are present in an [archetypes.Image].
+///
+/// This combined with [components.ChannelDataType] determines the pixel format of an image.
+enum ColorModel: byte {
+    /// Grayscale luminance intencity/brightness/value, sometimes called `Y`
+    L (default),
+
+    /// Red, Green, Blue
+    RGB,
+
+    /// Red, Green, Blue, Alpha
+    RGBA,
+}

crates/store/re_types/definitions/rerun/components/resolution2d.fbs

@@ -0,0 +1,20 @@
+include "arrow/attributes.fbs";
+include "python/attributes.fbs";
+include "rust/attributes.fbs";
+
+include "rerun/datatypes.fbs";
+include "rerun/attributes.fbs";
+
+namespace rerun.components;
+
+// ---
+
+/// The width and height of a 2D image.
+struct Resolution2D (
+  "attr.python.aliases": "npt.NDArray[np.int], Sequence[int], Tuple[int, int]",
+  "attr.python.array_aliases": "npt.NDArray[np.int], Sequence[int]",
+  "attr.rust.derive": "Default, Copy, PartialEq, Eq, Hash, bytemuck::Pod, bytemuck::Zeroable",
+  "attr.rust.repr": "transparent"
+) {
+  wh: rerun.datatypes.UVec2D (order: 100);
+}