Merge remote-tracking branch 'upstream/ign-gazebo6' into nontemplate_views

Author: azeey

src/EntityComponentManager.cc

@@ -1912,6 +1912,10 @@ void EntityComponentManager::SetChanged(
     auto oneTimeIter = this->dataPtr->oneTimeChangedComponents.find(_type);
     if (oneTimeIter != this->dataPtr->oneTimeChangedComponents.end())
       oneTimeIter->second.erase(_entity);
+
+    // the component state is flagged as no change, so don't mark the
+    // corresponding entity as one with a modified component
+    return;
   }
 
   this->dataPtr->AddModifiedComponent(_entity);

src/EntityComponentManager_TEST.cc

@@ -2238,6 +2238,17 @@ TEST_P(EntityComponentManagerFixture,
   EXPECT_EQ(ComponentState::NoChange,
       manager.ComponentState(e2, c2->TypeId()));
 
+  // Marking a component that isn't changed as unchanged again shouldn't effect
+  // the ecm's changed state
+  manager.RunClearNewlyCreatedEntities();
+  EXPECT_EQ(0, manager.ChangedState().entities_size());
+  manager.SetChanged(e1, c1->TypeId(), ComponentState::NoChange);
+  EXPECT_EQ(ComponentState::NoChange,
+      manager.ComponentState(e1, c1->TypeId()));
+  EXPECT_FALSE(manager.HasOneTimeComponentChanges());
+  EXPECT_EQ(0u, manager.ComponentTypesWithPeriodicChanges().size());
+  EXPECT_EQ(0, manager.ChangedState().entities_size());
+
   // Mark as changed
   manager.SetChanged(e1, c1->TypeId(), ComponentState::PeriodicChange);
 

src/rendering/SceneManager.cc

@@ -1776,6 +1776,9 @@ bool SceneManager::AddSensor(Entity _gazeboId, const std::string &_sensorName,
     return false;
   }
 
+  // \todo(anyone) change to uint64_t once UserData supports this type
+  sensor->SetUserData("gazebo-entity", static_cast<int>(_gazeboId));
+
   if (parent)
   {
     sensor->RemoveParent();

test/integration/CMakeLists.txt

@@ -139,3 +139,9 @@ set_tests_properties(INTEGRATION_tracked_vehicle_system PROPERTIES TIMEOUT 300)
 if(TARGET INTEGRATION_examples_build)
   set_tests_properties(INTEGRATION_examples_build PROPERTIES TIMEOUT 320)
 endif()
+
+if(VALID_DISPLAY AND VALID_DRI_DISPLAY)
+  target_link_libraries(INTEGRATION_sensors_system
+    ignition-rendering${IGN_RENDERING_VER}::ignition-rendering${IGN_RENDERING_VER}
+  )
+endif()

test/integration/sensors_system.cc

@@ -18,6 +18,7 @@
 #include <gtest/gtest.h>
 
 #include <string>
+#include <unordered_set>
 #include <vector>
 
 #include <sdf/Model.hh>
@@ -27,6 +28,11 @@
 #include <ignition/transport/Node.hh>
 #include <ignition/utilities/ExtraTestMacros.hh>
 
+#include <ignition/rendering/Camera.hh>
+#include <ignition/rendering/RenderEngine.hh>
+#include <ignition/rendering/RenderingIface.hh>
+#include <ignition/rendering/Scene.hh>
+
 #include "ignition/gazebo/EntityComponentManager.hh"
 #include "ignition/gazebo/EventManager.hh"
 #include "ignition/gazebo/SdfEntityCreator.hh"
@@ -37,15 +43,57 @@
 
 #include "ignition/gazebo/components/Model.hh"
 #include "ignition/gazebo/components/Name.hh"
+#include "ignition/gazebo/components/Sensor.hh"
 #include "ignition/gazebo/components/World.hh"
 
+#include "ignition/gazebo/rendering/Events.hh"
+
 #include "plugins/MockSystem.hh"
 #include "../helpers/EnvTestFixture.hh"
 
 using namespace ignition;
 using namespace std::chrono_literals;
 namespace components = ignition::gazebo::components;
 
+std::unordered_set<gazebo::Entity> g_sensorEntityIds;
+rendering::ScenePtr g_scene;
+
+/////////////////////////////////////////////////
+void OnPostRender()
+{
+  if (!g_scene)
+  {
+    g_scene = rendering::sceneFromFirstRenderEngine();
+  }
+  ASSERT_TRUE(g_scene);
+
+  EXPECT_LT(0u, g_scene->SensorCount());
+  for (unsigned int i = 0; i < g_scene->SensorCount(); ++i)
+  {
+    auto sensor = g_scene->SensorByIndex(i);
+    ASSERT_TRUE(sensor);
+    EXPECT_TRUE(sensor->HasUserData("gazebo-entity"));
+    auto variant = sensor->UserData("gazebo-entity");
+
+    // todo(anyone) change int to uint64_t once user data supports it
+    const int *value = std::get_if<int>(&variant);
+    ASSERT_TRUE(value);
+    g_sensorEntityIds.insert(*value);
+  }
+}
+
+/////////////////////////////////////////////////
+void testSensorEntityIds(const gazebo::EntityComponentManager &_ecm,
+    const std::unordered_set<gazebo::Entity> &_ids)
+{
+  EXPECT_FALSE(_ids.empty());
+  for (const auto & id : _ids)
+  {
+    auto sensorComp = _ecm.Component<gazebo::components::Sensor>(id);
+    EXPECT_TRUE(sensorComp);
+  }
+}
+
 //////////////////////////////////////////////////
 class SensorsFixture : public InternalFixture<InternalFixture<::testing::Test>>
 {
@@ -127,20 +175,35 @@ TEST_F(SensorsFixture, IGN_UTILS_TEST_DISABLED_ON_MAC(HandleRemovedEntities))
 
   gazebo::Server server(serverConfig);
 
+  common::ConnectionPtr postRenderConn;
+
   // A pointer to the ecm. This will be valid once we run the mock system
   gazebo::EntityComponentManager *ecm = nullptr;
   this->mockSystem->preUpdateCallback =
     [&ecm](const gazebo::UpdateInfo &, gazebo::EntityComponentManager &_ecm)
     {
       ecm = &_ecm;
     };
+  this->mockSystem->configureCallback =
+    [&](const gazebo::Entity &,
+           const std::shared_ptr<const sdf::Element> &,
+           gazebo::EntityComponentManager &,
+           gazebo::EventManager &_eventMgr)
+    {
+      postRenderConn = _eventMgr.Connect<gazebo::events::PostRender>(
+          std::bind(&::OnPostRender));
+    };
 
   server.AddSystem(this->systemPtr);
   server.Run(true, 50, false);
   ASSERT_NE(nullptr, ecm);
 
   testDefaultTopics();
 
+  testSensorEntityIds(*ecm, g_sensorEntityIds);
+  g_sensorEntityIds.clear();
+  g_scene.reset();
+
   // We won't use the event manager but it's required to create an
   // SdfEntityCreator
   gazebo::EventManager dummyEventMgr;

tutorials.md.in

@@ -38,6 +38,7 @@ Ignition @IGN_DESIGNATION_CAP@ library and how to use the library effectively.
 * \subpage test_fixture "Test Fixture": Writing automated CI tests
 * \subpage spherical_coordinates "Spherical coordinates": Working with latitude and longitude
 * \subpage python_interfaces Python interfaces
+* \subpage headless_rendering "Headless rendering": Access the GPU on a remote machine to produce sensor data without an X server.
 
 **Migration from Gazebo classic**
 

tutorials/headless_rendering.md

@@ -0,0 +1,76 @@
+\page headless_rendering Headless Rendering 
+  
+It is often desirable to run simulation on a remote computer, such as
+a computer managed by cloud provider, in order to paralellize work or access
+specific compute resources. Simulated sensors that require GPU access have
+historically been difficult to use on a remote computer due to OpenGL's
+X server requirement on linux systems. This issue can be resolved through
+installation and proper configuration of X, but the steps can be complex and
+error prone.
+
+An easier solution is through the use of [EGL](https://www.khronos.org/egl), which allows for the the creation of rendering surfaces without an X server. Ignition Gazebo has added support for EGL via the `--headless-rendering` command line option. Use of EGL is only available with OGRE2.
+
+Example usage:
+
+```
+ign gazebo -v 4 -s --headless-rendering sensors_demo.sdf
+```
+
+If you are using Ignition Gazebo as a library, then you can configure the
+server to use headless rendering through the
+`ServerConfig::SetHeadlessRendering(bool)` function. Make sure your SDF
+world uses OGRE2.
+
+## AWS Example
+
+This example will guide you through the process of launching and configuring
+an AWS GPU instance with Gazebo running headless. A GPU instance is
+recommended when sensors that require a render engine are used. It is
+possible to use a machine without a GPU, in which case OGRE will revert to
+software rendering. You can read more about [OGRE's EGL implementation
+here](https://www.ogre3d.org/2021/02/06/ogre-2-2-5-cerberus-released-and-egl-headless-support).
+
+1. Go to the [AWS EC2 service](https://console.aws.amazon.com/ec2)
+2. Click the `Launch Instance` button in the upper right.
+3. Select `Ubuntu Server` version 20.04 or greater from the AMI list.
+4. Choose a GPU enabled instance type, such as `g3.4xlarge`.
+5. Enable `Auto-assign Public IP` on the `Configure Instance Details` step.
+   This is not the best practice, but it simplifies this tutorial. 
+6. Add around 200GB storage to your instance on the `Add Storage` step.
+7. Enable ssh source `Anywhere` on the `Configure Security Group` step.
+8. Review and launch your instance. Make sure to setup a key pair in the
+   popup that appears after clicking `Launch`.
+    1. You can configure other options as needed. Review the [AWS
+   documentation](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) for additional help.
+9. Select the newly launched instance on the EC2 dashboard, and take note of
+   the `Public IPv4 address`.
+10. SSH into your new machine instance.
+  ```
+  ssh -i SSH_PEM_FILE_USED_DURING_LAUNCH ubuntu@EC_INSTANCE_PUBLIC_IP
+  ```
+12. Install Ubuntu drivers, which will install nvidia drivers:
+  ```
+  sudo apt-get update
+  sudo apt install ubuntu-drivers-common
+  sudo ubuntu-drivers install
+  ```
+13. Add the `ubuntu` user to the `render` group, which is required to access
+    to the dri interfaces.
+  ```
+  sudo usermod -a -G render ubuntu
+  ```
+14. Reboot the machine and log back in.
+  ```
+  sudo reboot
+  ```
+11. [Install Gazebo](https://ignitionrobotics.org/docs/latest/install).
+12. Run a Gazebo world that uses OGRE2 with camera sensors using headless rendering. This will enable EGL.
+  ```
+  ign gazebo -v 4 -s -r --headless-rendering sensors_demo.sdf
+  ```
+13. Check that simulation is producing sensor data by ssh'ing into the EC2
+    instance from a new terminal and echoing a sensor topic.
+  ```
+  ssh -i SSH_PEM_FILE_USED_DURING_LAUNCH ubuntu@EC_INSTANCE_PUBLIC_IP
+  ign topic -et /thermal_camera
+  ```