Fix user settings of thermal camera being ignored (#1138)

Fixes #1134

Changes to thermal camera settings that can be made through the plugin
gz-sim-thermal-sensor-system would not show up in the result. While the
value of the data members was updated, the named constants in the
material shader used for rendering were not. We fix that by always
setting the shader constants in PreRender to the current values.

This might be relevant for other thermal camera settings as well, but
this focuses on min and max temperature and resolution, as those can be
modified through the gz-sim-thermal-sensor-system plugin.

---------

Signed-off-by: Marcel Jacobse <[email protected]>

Author: mjacobse

ogre2/src/Ogre2ThermalCamera.cc

@@ -1120,6 +1120,21 @@ void Ogre2ThermalCamera::PreRender()
   if (!this->dataPtr->ogreThermalTexture)
     this->CreateThermalTexture();
 
+  // ensure that certain shader constants are up-to-date so that changes that
+  // users can make to the settings show up in the thermal result immediately
+  Ogre::Pass *pass =
+      this->dataPtr->thermalMaterial->getTechnique(0)->getPass(0);
+  Ogre::GpuProgramParametersSharedPtr psParams =
+      pass->getFragmentProgramParameters();
+  psParams->setNamedConstant("max",
+      static_cast<float>(this->maxTemp));
+  psParams->setNamedConstant("min",
+      static_cast<float>(this->minTemp));
+  psParams->setNamedConstant("resolution",
+      static_cast<float>(this->resolution));
+
+  this->dataPtr->thermalMaterialSwitcher->SetLinearResolution(this->resolution);
+
   // todo(iche033) Override BaseCamera::SetProjectionMatrix() function in
   // main / gz-rendering9 instead of checking and setting the custom
   // projection matrix here

test/integration/thermal_camera.cc

@@ -818,3 +818,213 @@ TEST_F(ThermalCameraTest, ThermalCameraMaxTemperatureIsClamped)
 
   engine->DestroyScene(scene);
 }
+
+//////////////////////////////////////////////////
+TEST_F(ThermalCameraTest, ThermalCameraMinTemperatureUpdate)
+{
+  // Updating the min temperature currently only works with Ogre2
+  CHECK_SUPPORTED_ENGINE("ogre2");
+
+  const unsigned int imgWidth = 50;
+  const unsigned int imgHeight = 50;
+
+  gz::rendering::ScenePtr scene = engine->CreateScene("scene");
+
+  {
+    // Create thermal camera
+    auto thermalCamera = scene->CreateThermalCamera("ThermalCamera");
+    ASSERT_NE(thermalCamera, nullptr);
+
+    // Configure thermal camera
+    thermalCamera->SetImageWidth(imgWidth);
+    EXPECT_EQ(thermalCamera->ImageWidth(), imgWidth);
+    thermalCamera->SetImageHeight(imgHeight);
+    EXPECT_EQ(thermalCamera->ImageHeight(), imgHeight);
+
+    scene->RootVisual()->AddChild(thermalCamera);
+
+    // Set a callback on the camera sensor to get a thermal camera frame
+    std::vector<uint16_t> thermalData(imgHeight * imgWidth);
+    gz::common::ConnectionPtr connection =
+      thermalCamera->ConnectNewThermalFrame(
+          std::bind(&::OnNewThermalFrame, thermalData.data(),
+            std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
+            std::placeholders::_4, std::placeholders::_5));
+    EXPECT_NE(nullptr, connection);
+
+    const float linearResolution = 0.01f;
+    thermalCamera->SetLinearResolution(linearResolution);
+    EXPECT_FLOAT_EQ(linearResolution, thermalCamera->LinearResolution());
+
+    // set a minimum temperature and a smaller ambient temperature
+    const float minTemp = 100.0f;
+    const float ambientTemp = 50.0f;
+    thermalCamera->SetMinTemperature(minTemp);
+    EXPECT_FLOAT_EQ(minTemp, thermalCamera->MinTemperature());
+    thermalCamera->SetAmbientTemperature(ambientTemp);
+    EXPECT_FLOAT_EQ(ambientTemp, thermalCamera->AmbientTemperature());
+
+    // Update once to create image
+    thermalCamera->Update();
+
+    for (const uint16_t value : thermalData) {
+      const float temp = static_cast<float>(value) * linearResolution;
+      EXPECT_NEAR(temp, minTemp, linearResolution);
+    }
+
+    // set new minimum temperature
+    const float newMinTemp = 150.0f;
+    thermalCamera->SetMinTemperature(newMinTemp);
+    thermalCamera->Update();
+
+    // check that new minimum temperature is applied
+    for (const uint16_t value : thermalData) {
+      const float temp = static_cast<float>(value) * linearResolution;
+      EXPECT_NEAR(temp, newMinTemp, linearResolution);
+    }
+
+    // Clean up
+    connection.reset();
+  }
+
+  engine->DestroyScene(scene);
+}
+
+//////////////////////////////////////////////////
+TEST_F(ThermalCameraTest, ThermalCameraMaxTemperatureUpdate)
+{
+  // Updating the max temperature currently only works with Ogre2
+  CHECK_SUPPORTED_ENGINE("ogre2");
+
+  const unsigned int imgWidth = 50;
+  const unsigned int imgHeight = 50;
+
+  gz::rendering::ScenePtr scene = engine->CreateScene("scene");
+
+  {
+    // Create thermal camera
+    auto thermalCamera = scene->CreateThermalCamera("ThermalCamera");
+    ASSERT_NE(thermalCamera, nullptr);
+
+    // Configure thermal camera
+    thermalCamera->SetImageWidth(imgWidth);
+    EXPECT_EQ(thermalCamera->ImageWidth(), imgWidth);
+    thermalCamera->SetImageHeight(imgHeight);
+    EXPECT_EQ(thermalCamera->ImageHeight(), imgHeight);
+
+    scene->RootVisual()->AddChild(thermalCamera);
+
+    // Set a callback on the camera sensor to get a thermal camera frame
+    std::vector<uint16_t> thermalData(imgHeight * imgWidth);
+    gz::common::ConnectionPtr connection =
+      thermalCamera->ConnectNewThermalFrame(
+          std::bind(&::OnNewThermalFrame, thermalData.data(),
+            std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
+            std::placeholders::_4, std::placeholders::_5));
+    EXPECT_NE(nullptr, connection);
+
+    const float linearResolution = 0.01f;
+    thermalCamera->SetLinearResolution(linearResolution);
+    EXPECT_FLOAT_EQ(linearResolution, thermalCamera->LinearResolution());
+
+    // set a maximum temperature and a greater ambient temperature
+    const float maxTemp = 500.0f;
+    const float ambientTemp = 550.0f;
+    thermalCamera->SetMaxTemperature(maxTemp);
+    EXPECT_FLOAT_EQ(maxTemp, thermalCamera->MaxTemperature());
+    thermalCamera->SetAmbientTemperature(ambientTemp);
+    EXPECT_FLOAT_EQ(ambientTemp, thermalCamera->AmbientTemperature());
+
+    // Update once to create image
+    thermalCamera->Update();
+
+    for (const uint16_t value : thermalData) {
+      const float temp = static_cast<float>(value) * linearResolution;
+      EXPECT_NEAR(temp, maxTemp, linearResolution);
+    }
+
+    // set new maximum temperature
+    const float newMaxTemp = 525.0f;
+    thermalCamera->SetMaxTemperature(newMaxTemp);
+    thermalCamera->Update();
+
+    // check that new maximum temperature is applied
+    for (const uint16_t value : thermalData) {
+      const float temp = static_cast<float>(value) * linearResolution;
+      EXPECT_NEAR(temp, newMaxTemp, linearResolution);
+    }
+
+    // Clean up
+    connection.reset();
+  }
+
+  engine->DestroyScene(scene);
+}
+
+//////////////////////////////////////////////////
+TEST_F(ThermalCameraTest, ThermalCameraResolutionUpdate)
+{
+  // Updating the resolution currently only works with Ogre2
+  CHECK_SUPPORTED_ENGINE("ogre2");
+
+  const unsigned int imgWidth = 50;
+  const unsigned int imgHeight = 50;
+
+  gz::rendering::ScenePtr scene = engine->CreateScene("scene");
+
+  {
+    // Create thermal camera
+    auto thermalCamera = scene->CreateThermalCamera("ThermalCamera");
+    ASSERT_NE(thermalCamera, nullptr);
+
+    // Configure thermal camera
+    thermalCamera->SetImageWidth(imgWidth);
+    EXPECT_EQ(thermalCamera->ImageWidth(), imgWidth);
+    thermalCamera->SetImageHeight(imgHeight);
+    EXPECT_EQ(thermalCamera->ImageHeight(), imgHeight);
+
+    scene->RootVisual()->AddChild(thermalCamera);
+
+    // Set a callback on the camera sensor to get a thermal camera frame
+    std::vector<uint16_t> thermalData(imgHeight * imgWidth);
+    gz::common::ConnectionPtr connection =
+      thermalCamera->ConnectNewThermalFrame(
+          std::bind(&::OnNewThermalFrame, thermalData.data(),
+            std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
+            std::placeholders::_4, std::placeholders::_5));
+    EXPECT_NE(nullptr, connection);
+
+    const float ambientTemp = 300.0f;
+    thermalCamera->SetAmbientTemperature(ambientTemp);
+    EXPECT_FLOAT_EQ(ambientTemp, thermalCamera->AmbientTemperature());
+
+    const float linearResolution = 0.01f;
+    thermalCamera->SetLinearResolution(linearResolution);
+    EXPECT_FLOAT_EQ(linearResolution, thermalCamera->LinearResolution());
+
+    // Update once to create image
+    thermalCamera->Update();
+
+    // check result with initial resolution
+    for (const uint16_t value : thermalData) {
+      const float temp = static_cast<float>(value) * linearResolution;
+      EXPECT_NEAR(temp, ambientTemp, linearResolution);
+    }
+
+    // set new resolution
+    const float newLinearResolution = 0.02f;
+    thermalCamera->SetLinearResolution(newLinearResolution);
+    thermalCamera->Update();
+
+    // check that camera has applied the new resolution
+    for (const uint16_t value : thermalData) {
+      const float temp = static_cast<float>(value) * newLinearResolution;
+      EXPECT_NEAR(temp, ambientTemp, newLinearResolution);
+    }
+
+    // Clean up
+    connection.reset();
+  }
+
+  engine->DestroyScene(scene);
+}