Function renderPointCloudAssetPreview

src/python/lfs/py_rendering.cpp:203–259

        }

        [[nodiscard]] std::optional<core::Tensor> renderPointCloudAssetPreview(
            vis::RenderingManager& rendering_manager,
            const core::PointCloud& point_cloud,
            const int width,
            const int height,
            const float focal_length_mm,
            const glm::mat3* custom_rotation = nullptr,
            const glm::vec3* custom_translation = nullptr) {
            if (point_cloud.size() == 0) {
                return std::nullopt;
            }

            auto* const engine = rendering_manager.getRenderingEngine();
            if (!engine) {
                return std::nullopt;
            }

            Viewport preview_viewport(
                static_cast<std::size_t>(width),
                static_cast<std::size_t>(height));
            if (custom_rotation && custom_translation) {
                preview_viewport.setViewMatrix(*custom_rotation, *custom_translation);
            } else {
                preview_viewport.camera.resetToHome();
            }

            std::vector<glm::mat4> model_transforms{
                rendering::dataWorldTransformToVisualizerWorld(glm::mat4(1.0f)),
            };
            auto transform_indices = std::make_shared<core::Tensor>(
                core::Tensor::zeros(
                    {static_cast<std::size_t>(point_cloud.size())},
                    core::Device::CUDA,
                    core::DataType::Int32));

            rendering::PointCloudRenderRequest request{};
            request.frame_view.rotation = preview_viewport.getRotationMatrix();
            request.frame_view.translation = preview_viewport.getTranslation();
            request.frame_view.size = {width, height};
            request.frame_view.focal_length_mm = focal_length_mm;
            request.render.scaling_modifier = 1.0f;
            request.render.voxel_size = 0.01f;
            request.render.equirectangular = false;
            request.scene.model_transforms = &model_transforms;
            request.scene.transform_indices = std::move(transform_indices);
            request.scene.node_visibility_mask = {true};
            request.transparent_background = false;

            auto render_result = engine->renderPointCloudImage(point_cloud, request);
            if (!render_result || !render_result->image || !render_result->image->is_valid()) {
                if (!render_result) {
                    LOG_DEBUG("Point-cloud asset preview render failed: {}", render_result.error());
                }
                return std::nullopt;
            }
            return render_result->image->clone();
        }