Update factories to consistently pass subconfigs to subfactories

library/cpp/src/core/integrator/integrator_factory.cc

@@ -60,10 +60,16 @@ std::unique_ptr<IntegratorBase> IntegratorFactory::create(
   }
 
   // Create the projection model
+  const auto projector_params = params.getChild("projection_model");
+  if (!projector_params) {
+    LOG(ERROR) << "No params with key \"projection_model\". "
+                  "Projection model could not be created.";
+    return nullptr;
+  }
   std::shared_ptr<ProjectorBase> projection_model =
-      ProjectorFactory::create(params);
+      ProjectorFactory::create(projector_params.value());
   if (!projection_model) {
-    LOG(ERROR) << "Projection model could not be created.";
+    LOG(ERROR) << "Creating projection model failed.";
     return nullptr;
   }
 
@@ -75,11 +81,18 @@ std::unique_ptr<IntegratorBase> IntegratorFactory::create(
       std::make_shared<Image<Vector2D>>(projection_model->getDimensions());
 
   // Create the measurement model
+  const auto measurement_params = params.getChild("measurement_model");
+  if (!measurement_params) {
+    LOG(ERROR) << "No params with key \"measurement_model\". "
+                  "Measurement model could not be created.";
+    return nullptr;
+  }
   std::shared_ptr<MeasurementModelBase> measurement_model =
-      MeasurementModelFactory::create(params, projection_model,
-                                      posed_range_image, beam_offset_image);
+      MeasurementModelFactory::create(measurement_params.value(),
+                                      projection_model, posed_range_image,
+                                      beam_offset_image);
   if (!measurement_model) {
-    LOG(ERROR) << "Measurement model could not be created.";
+    LOG(ERROR) << "Creating measurement model failed.";
     return nullptr;
   }
 

library/cpp/src/core/integrator/measurement_model/measurement_model_factory.cc

@@ -11,8 +11,7 @@ std::unique_ptr<MeasurementModelBase> wavemap::MeasurementModelFactory::create(
     const param::Value& params, ProjectorBase::ConstPtr projection_model,
     Image<>::ConstPtr range_image, Image<Vector2D>::ConstPtr beam_offset_image,
     std::optional<MeasurementModelType> default_measurement_model_type) {
-  if (const auto type = MeasurementModelType::from(params, "measurement_model");
-      type) {
+  if (const auto type = MeasurementModelType::from(params); type) {
     return create(type.value(), std::move(projection_model),
                   std::move(range_image), std::move(beam_offset_image), params);
   }
@@ -36,9 +35,7 @@ std::unique_ptr<MeasurementModelBase> wavemap::MeasurementModelFactory::create(
     Image<Vector2D>::ConstPtr beam_offset_image, const param::Value& params) {
   switch (measurement_model_type) {
     case MeasurementModelType::kContinuousRay: {
-      if (const auto config =
-              ContinuousRayConfig::from(params, "measurement_model");
-          config) {
+      if (const auto config = ContinuousRayConfig::from(params); config) {
         return std::make_unique<ContinuousRay>(config.value(),
                                                std::move(projection_model),
                                                std::move(range_image));
@@ -49,9 +46,7 @@ std::unique_ptr<MeasurementModelBase> wavemap::MeasurementModelFactory::create(
       }
     }
     case MeasurementModelType::kContinuousBeam: {
-      if (const auto config =
-              ContinuousBeamConfig::from(params, "measurement_model");
-          config) {
+      if (const auto config = ContinuousBeamConfig::from(params); config) {
         return std::make_unique<ContinuousBeam>(
             config.value(), std::move(projection_model), std::move(range_image),
             std::move(beam_offset_image));

library/cpp/src/core/integrator/projection_model/projector_factory.cc

@@ -10,7 +10,7 @@ namespace wavemap {
 std::unique_ptr<ProjectorBase> wavemap::ProjectorFactory::create(
     const param::Value& params,
     std::optional<ProjectorType> default_projector_type) {
-  if (const auto type = ProjectorType::from(params, "projection_model"); type) {
+  if (const auto type = ProjectorType::from(params); type) {
     return create(type.value(), params);
   }
 
@@ -28,28 +28,23 @@ std::unique_ptr<ProjectorBase> wavemap::ProjectorFactory::create(
     ProjectorType projector_type, const param::Value& params) {
   switch (projector_type) {
     case ProjectorType::kSphericalProjector: {
-      if (const auto config =
-              SphericalProjectorConfig::from(params, "projection_model");
-          config) {
+      if (const auto config = SphericalProjectorConfig::from(params); config) {
         return std::make_unique<SphericalProjector>(config.value());
       } else {
         LOG(ERROR) << "Spherical projector config could not be loaded.";
         return nullptr;
       }
     }
     case ProjectorType::kOusterProjector: {
-      if (const auto config =
-              OusterProjectorConfig::from(params, "projection_model");
-          config) {
+      if (const auto config = OusterProjectorConfig::from(params); config) {
         return std::make_unique<OusterProjector>(config.value());
       } else {
         LOG(ERROR) << "Ouster projector config could not be loaded.";
         return nullptr;
       }
     }
     case ProjectorType::kPinholeCameraProjector: {
-      if (const auto config =
-              PinholeCameraProjectorConfig::from(params, "projection_model");
+      if (const auto config = PinholeCameraProjectorConfig::from(params);
           config) {
         return std::make_unique<PinholeCameraProjector>(config.value());
       } else {