copilot review. Consistent device use.

ssheorey · ssheorey · commit bc27b615190d · 2026-05-17T23:11:26.000-07:00
Switch to tbb parallel reduce, for export depth image, since AppleClang lacks execution policy.
diff --git a/cpp/open3d/core/Tensor.cpp b/cpp/open3d/core/Tensor.cpp
@@ -1174,7 +1174,7 @@ Tensor Tensor::Cross(const Tensor& other, int64_t axis) const {
         utility::LogError(
                 "[Tensor::Cross] Dim axis={} of both tensors must have shape "
                 "3. Got {} and {} instead.",
-                axis, GetShape(3), other.GetShape(3));
+                axis, GetShape(axis), other.GetShape(axis));
     }
     Tensor t_x = Slice(axis, 0, 1), t_y = Slice(axis, 1, 2),
            t_z = Slice(axis, 2, 3);
diff --git a/cpp/open3d/core/Tensor.h b/cpp/open3d/core/Tensor.h
@@ -411,7 +411,6 @@ class Tensor : public IsDevice {
     /// t = np.empty((4, 5), dtype=np.float32)
     /// t[2, 0:4:2] = np.empty((2, 5), dtype=np.float32)
     /// ```
-    ///    Tensor Cross(const Tensor &b) const;
     /// The equivalent Open3D C++ calls:
     /// ```cpp
     /// Tensor t({4, 5}, core::Float32);
@@ -636,14 +635,15 @@ class Tensor : public IsDevice {
     /// tensor.
     ///
     /// The cross product is computed along the specified axis. The tensors must
-    /// have compatible
-    // (i.e. broadcastable) shape, and the size of the specified axis must be 3.
-    // If the axis is -1 (default), the last axis is used.
+    /// have compatible (i.e. broadcastable) shape, and the size of the
+    /// specified axis must be 3.  If the axis is -1 (default), the last axis is
+    /// used.
     ///
     /// \param other The second input tensor to compute the cross product with.
     /// \param axis The axis along which to compute the cross product. Default
-    /// is -1 (the last axis). \return A tensor containing the cross product of
-    /// the two input tensors along the specified axis.
+    /// is -1 (the last axis).
+    /// \return A tensor containing the cross product of the two input tensors
+    /// along the specified axis.
     Tensor Cross(const Tensor& other, int64_t axis = -1) const;
 
     /// Helper function to return scalar value of a scalar Tensor, the Tensor
@@ -842,8 +842,8 @@ class Tensor : public IsDevice {
     /// with size 1.
     /// \param p The order of the norm. Default is 2.0 (L2 norm). Can be
     /// positive infinity (L-infinity norm).
-    /// \return Tensor containing the computed norms. Dtype is
-    /// preserved for Float32 and Float64 for L2 norm, It is onverted to Float32
+    /// \return Tensor containing the computed norms. Dtype is preserved for
+    /// Float32 and Float64 for L2 norm, It is converted to Float32
     /// for all other cases.
     Tensor Norm(const SizeVector& dims = {},
                 bool keepdim = false,
diff --git a/cpp/open3d/t/geometry/TriangleMesh.cpp b/cpp/open3d/t/geometry/TriangleMesh.cpp
@@ -25,6 +25,7 @@
 #include <mutex>
 #include <string>
 #include <tuple>
+#include <unordered_map>
 
 #include "open3d/core/CUDAUtils.h"
 #include "open3d/core/Device.h"
@@ -1945,8 +1946,7 @@ Image TriangleMesh::ComputeAmbientOcclusion(int tex_width,
     }
 
     // Bake positions and normals into textures.
-    const float margin =
-            (tex_width + 511.f) / 512.f;  // = ceil(tex_width / 512)
+    const float margin = (tex_width + 511) / 512;  // = ceil(tex_width / 512)
     auto baked_textures =
             BakeVertexAttrTextures(tex_width, {"positions", "normals"}, margin,
                                    /*fill=*/0.0, /*update_material=*/false);
@@ -1957,7 +1957,7 @@ Image TriangleMesh::ComputeAmbientOcclusion(int tex_width,
 
     RaycastingScene rcs;
     // TODO: Reuse RCS from BakeVertexAttrTextures() if possible.
-    rcs.AddTriangles(*this);  
+    rcs.AddTriangles(*this);
 
     const int64_t n_pixels = tex_width * tex_width;
 
@@ -2234,12 +2234,15 @@ Image TriangleMesh::TransformNormalMap(const Image &normal_map,
                 "Use ComputeVertexNormals() and ComputeTangentSpace() to "
                 "compute them.");
     }
-
     if (normal_map.GetChannels() != 3) {
         utility::LogError("Normal map must have 3 channels, but has {}.",
                           normal_map.GetChannels());
     }
-
+    const core::Device device = GetDevice();
+    if (normal_map.GetDevice() != device) {
+        utility::LogError("Normal map device {} does not match mesh device {}.",
+                          normal_map.GetDevice().ToString(), device.ToString());
+    }
     int tex_width = normal_map.GetCols();
     int tex_height = normal_map.GetRows();
     if (tex_width != tex_height) {
@@ -2250,8 +2253,7 @@ Image TriangleMesh::TransformNormalMap(const Image &normal_map,
     }
 
     // Bake TBN vectors into textures.
-    const float margin =
-            (tex_width + 511.f) / 512.f;  // = ceil(tex_width / 512)
+    const float margin = (tex_width + 511) / 512;  // = ceil(tex_width / 512)
     if (!HasMaterial()) {
         SetMaterial(visualization::rendering::Material());
         GetMaterial().SetDefaultProperties();  // defaultLit
@@ -2260,18 +2262,19 @@ Image TriangleMesh::TransformNormalMap(const Image &normal_map,
     std::unordered_map<std::string, core::Tensor> baked_textures;
     if (!(GetMaterial().HasTextureMap("normals") &&
           GetMaterial().HasTextureMap("tangents"))) {
+        // BakeVertexAttrTextures requires CPU; move results back to the mesh
+        // device for all subsequent computation.
         baked_textures = To(core::Device("CPU:0"))
                                  .BakeVertexAttrTextures(
                                          tex_width, {"normals", "tangents"},
                                          margin, /*fill=*/0.0, false);
+        baked_textures["normals"] = baked_textures["normals"].To(device);
+        baked_textures["tangents"] = baked_textures["tangents"].To(device);
     } else {
         baked_textures["normals"] =
-                GetMaterial().GetTextureMap("normals").AsTensor().To(
-                        core::Device("CPU:0"));
-        baked_textures["tangents"] = GetMaterial()
-                                             .GetTextureMap("tangents")
-                                             .AsTensor()
-                                             .To(core::Device("CPU:0"));
+                GetMaterial().GetTextureMap("normals").AsTensor().To(device);
+        baked_textures["tangents"] =
+                GetMaterial().GetTextureMap("tangents").AsTensor().To(device);
     }
 
     // Baked (Interpolated) TBN vectors are NOT normalized.
@@ -2314,8 +2317,8 @@ Image TriangleMesh::TransformNormalMap(const Image &normal_map,
                                      2.0f -
                              1.0f;
 
-        core::Tensor tangent_normals_t =
-                core::Tensor::Empty({tex_height, tex_width, 3}, core::Float32);
+        core::Tensor tangent_normals_t = core::Tensor::Empty(
+                {tex_height, tex_width, 3}, core::Float32, device);
         tangent_normals_t.Slice(2, 0, 1) =
                 fSign * (input_normals_t * row0).Sum({2}, true);
         tangent_normals_t.Slice(2, 1, 2) =
diff --git a/cpp/open3d/t/geometry/TriangleMesh.h b/cpp/open3d/t/geometry/TriangleMesh.h
@@ -1163,29 +1163,38 @@ class TriangleMesh : public Geometry, public DrawableGeometry {
                                   float max_hit_distance = INFINITY,
                                   bool update_material = true);
 
-    /// Computes tangent space for the triangle mesh with MikkTSpace.
-    /// The mesh must have vertex positions, vertex normals, and texture UVs
-    /// (triangle attribute 'texture_uvs'). The computed tangents and bitangents
-    /// will be added as vertex attributes 'tangents' and 'bitangents'.
+    /// Computes tangent space for the triangle mesh with MikkTSpace.  The mesh
+    /// must have vertex positions, vertex normals, and texture UVs (triangle
+    /// attribute 'texture_uvs'). The computed tangents will be added as vertex
+    /// attributes 'tangents' with shape {N, 4}, where the 4th element is the
+    /// sign.  Bitangents are normally computed as needed with the formula:
+    /// \verbatim
+    /// vB = sign * cross(vN, vT);
+    /// \endverbatim
     /// This function works on the CPU and will transfer data to the CPU if
     /// necessary.
-    /// \param bake If true, the tangents, bitangents and normals will also be
-    /// baked to textures and saved to the material.
+    /// \param bake If true, the tangents and normals will also be
+    /// baked to textures (unnormalized, interpolated) and saved to the
+    /// material.
     /// \param tex_width Baked texture size. Default 512.
     void ComputeTangentSpace(bool bake = true, int tex_width = 512);
 
     /// \brief Converts a normal map between world and tangent space.
     ///
     /// The conversion is performed for each pixel of the map. The mesh must
-    /// have vertex normals, tangents, bitangents, and texture UVs.
-    /// The tangent space attributes can be computed with
-    /// `ComputeTangentSpace()`.
+    /// have vertex normals (shape {N, 3}), tangents with sign (shape {N, 4})
+    /// and texture UVs.  The tangent space attributes can be computed with
+    /// `ComputeTangentSpace()`. Bitangents are normally computed as needed with
+    /// the formula:
+    /// \verbatim
+    /// vB = sign * cross(vN, vT);
+    /// \endverbatim
     ///
-    /// \param normal_map The normal map to convert.
-    /// When converting to tangent space, this is the world-space normal map.
-    /// When converting to world space, this is the tangent-space normal map.
-    /// It is expected to have 3 channels with Float32 or Float64 data type,
-    /// with values in range [-1, 1], or UInt8 data type in the range [0, 255].
+    /// \param normal_map The normal map to convert.  When converting to tangent
+    /// space, this is the world-space normal map.  When converting to world
+    /// space, this is the tangent-space normal map.  It is expected to have 3
+    /// channels with Float32 or Float64 data type, with values in range [-1,
+    /// 1], or UInt8 data type in the range [0, 255].
     /// \param to_tangent_space If true, converts from world to tangent space.
     /// If false, converts from tangent to world space.
     /// \param update_material If true and we are converting to tangent space,
diff --git a/cpp/open3d/visualization/visualizer/O3DVisualizer.cpp b/cpp/open3d/visualization/visualizer/O3DVisualizer.cpp
@@ -9,7 +9,7 @@
 
 #include <json/json.h>
 
-#include <execution>
+#include <cmath>
 #include <set>
 #include <unordered_map>
 
@@ -2162,43 +2162,49 @@ Ctrl-alt-click to polygon select)";
 
     void ExportCurrentDepthImage(const std::string &path) {
         scene_->EnableSceneCaching(false);
-        scene_->GetScene()->GetScene()->RenderToDepthImage(
-                [this, path](std::shared_ptr<geometry::Image> image) mutable {
-                    bool ok = false;
-                    if (image && image->num_of_channels_ == 1 &&
-                        image->bytes_per_channel_ == 4) {
-                        // Depth export stores normalized depth in 16-bit PNG.
-                        auto depth_float =
-                                std::make_shared<geometry::Image>(*image);
-                        float *depth_data = depth_float->PointerAs<float>();
-                        size_t num_pixels = static_cast<size_t>(
-                                depth_float->GetMaxBound().prod());
-                        float max_val =
-                                std::reduce(std::execution::par_unseq,
-                                            depth_data, depth_data + num_pixels,
-                                            0.0f, [](float a, float b) {
-                                                if (!std::isfinite(a)) return b;
-                                                if (!std::isfinite(b)) return a;
-                                                return std::max(a, b);
-                                            });
-                        if (max_val > 0)
-                            depth_float->LinearTransform(65535.0 / max_val,
-                                                         0.0);
-                        auto depth_u16 =
-                                depth_float
-                                        ->CreateImageFromFloatImage<uint16_t>();
-                        ok = io::WriteImage(path, *depth_u16);
-                    }
-                    if (!ok) {
-                        this->window_->ShowMessageBox(
-                                "Error",
-                                (std::string(
-                                         "Could not write depth image to ") +
-                                 path + ".")
-                                        .c_str());
-                    }
-                    scene_->EnableSceneCaching(true);
-                });
+        auto fs = scene_->GetScene()->GetScene();
+        fs->RenderToDepthImage([this,
+                                path](std::shared_ptr<geometry::Image> image) {
+            bool ok = false;
+            auto finite_max = [](float a, float b) {
+                if (!std::isfinite(a)) return b;
+                if (!std::isfinite(b)) return a;
+                return std::max(a, b);
+            };
+            if (image && image->num_of_channels_ == 1 &&
+                image->bytes_per_channel_ == 4) {
+                // Depth export stores normalized depth in 16-bit PNG.
+                auto depth_float = std::make_shared<geometry::Image>(*image);
+                float *depth_data = depth_float->PointerAs<float>();
+                size_t num_pixels =
+                        static_cast<size_t>(depth_float->GetMaxBound().prod());
+                auto depth_subrange_finite_max =
+                        [depth_data](const tbb::blocked_range<size_t> &r,
+                                     float cmax) {
+                            for (size_t i = r.begin(); i != r.end(); ++i) {
+                                if (std::isfinite(depth_data[i])) {
+                                    cmax = std::max(cmax, depth_data[i]);
+                                }
+                            }
+                            return cmax;
+                        };
+                float max_val = tbb::parallel_reduce(
+                        tbb::blocked_range<size_t>(0, num_pixels), -INFINITY,
+                        depth_subrange_finite_max, finite_max);
+                if (max_val > 0)
+                    depth_float->LinearTransform(65535.0 / max_val, 0.0);
+                auto depth_u16 =
+                        depth_float->CreateImageFromFloatImage<uint16_t>();
+                ok = io::WriteImage(path, *depth_u16);
+            }
+            if (!ok) {
+                this->window_->ShowMessageBox(
+                        "Error",
+                        fmt::format("Could not write depth image to {}.", path)
+                                .c_str());
+            }
+            scene_->EnableSceneCaching(true);
+        });
     }
 
     void OnAbout() {
@@ -2209,7 +2215,7 @@ Ctrl-alt-click to polygon select)";
                 (std::string("Open3D ") + OPEN3D_VERSION).c_str());
         auto text = std::make_shared<gui::Label>(
                 "The MIT License (MIT)\n"
-                "Copyright (c) 2018-2023 www.open3d.org\n\n"
+                "Copyright (c) 2018-2026 www.open3d.org\n\n"
 
                 "Permission is hereby granted, free of charge, to any person "
                 "obtaining a copy of this software and associated "
diff --git a/cpp/pybind/core/tensor.cpp b/cpp/pybind/core/tensor.cpp
@@ -785,8 +785,8 @@ tuple `output` tensor of shape {n,n} and `ipiv` tensor of shape {n}, where
  must be 3. If the axis is -1 (default), the last axis is used.
 
  Args:
-    other The second input tensor to compute the cross product with.
-    axis The axis along which to compute the cross product. Default is -1 (the
+    other: The second input tensor to compute the cross product with.
+    axis: The axis along which to compute the cross product. Default is -1 (the
         last axis).
 
  Returns:
diff --git a/cpp/pybind/t/geometry/trianglemesh.cpp b/cpp/pybind/t/geometry/trianglemesh.cpp
@@ -1266,8 +1266,10 @@ Example::
             R"(Computes tangent space for the triangle mesh with MikkTSpace.
     The mesh must have vertex positions, vertex normals, and texture UVs
     (triangle attribute 'texture_uvs'). The computed tangents will be added as
-    vertex attributes 'tangents' shape (N,4). This function works on the CPU and
-    will transfer data to the CPU if necessary.
+    vertex attributes 'tangents' shape (N,4), where the 4th element is the sign.
+    Bitangents are normally computed as needed with the formula:
+    ``vB = sign * cross(vN, vT);``
+    This function works on the CPU and will transfer data to the CPU if necessary.
     
     Args:
         bake (bool): If true, the normals and tangents will also be baked to
@@ -1281,8 +1283,8 @@ Example::
                       R"(Converts a normal map between world and tangent space.
     
     The conversion is performed for each pixel of the map. The mesh must
-    have vertex normals and tangents. The tangent space attributes can be
-    computed with `compute_tangent_space()`.
+    have vertex normals (shape (N, 3)) and tangents with sign (shape (N, 4)).
+    The tangent space attributes can be computed with `compute_tangent_space()`.
     
     Args:
         normal_map (o3d.t.geometry.Image): The normal map to convert.
diff --git a/cpp/tests/t/geometry/TriangleMesh.cpp b/cpp/tests/t/geometry/TriangleMesh.cpp
@@ -1685,8 +1685,9 @@ TEST_P(TriangleMeshPermuteDevices, TangentSpace) {
     world_map_t =
             world_map_t / world_map_t.Norm({2}, true).Clip_(1e-6, INFINITY);
     t::geometry::Image world_normal_map(world_map_t);
-    t::io::WriteImage("world_normal_map.png",
-                      world_normal_map.To(core::UInt8, false, 127.5f, 127.5f));
+    //  t::io::WriteImage("world_normal_map.png",
+    //                    world_normal_map.To(core::UInt8, false, 127.5f,
+    //                    127.5f));
 
     // 2. World to Tangent space.
     auto tangent_normal_map = mesh.TransformNormalMap(world_normal_map,

Original file line number	Diff line number	Diff line change
`@@ -1174,7 +1174,7 @@ Tensor Tensor::Cross(const Tensor& other, int64_t axis) const {`
`1174`	`1174`	`utility::LogError(`
`1175`	`1175`	`"[Tensor::Cross] Dim axis={} of both tensors must have shape "`
`1176`	`1176`	`"3. Got {} and {} instead.",`
`1177`		`- axis, GetShape(3), other.GetShape(3));`
	`1177`	`+ axis, GetShape(axis), other.GetShape(axis));`
`1178`	`1178`	`}`
`1179`	`1179`	`Tensor t_x = Slice(axis, 0, 1), t_y = Slice(axis, 1, 2),`
`1180`	`1180`	`t_z = Slice(axis, 2, 3);`