ENH: Add command to set MicrosoftMediaFoundation camera control parameters

Sunderlandkyl · Sunderlandkyl · commit 27537324cfa0 · 2025-07-30T12:39:52.000-04:00
diff --git a/src/PlusDataCollection/MicrosoftMediaFoundation/vtkPlusMmfVideoSource.cxx b/src/PlusDataCollection/MicrosoftMediaFoundation/vtkPlusMmfVideoSource.cxx
@@ -746,6 +746,17 @@ std::wstring vtkPlusMmfVideoSource::GetCaptureDeviceName(unsigned int deviceId)
   return MfVideoCapture::MediaFoundationVideoCaptureApi::GetInstance().GetCaptureDeviceName(deviceId);
 }
 
+//----------------------------------------------------------------------------
+PlusStatus vtkPlusMmfVideoSource::SetNewCameraControlParameters(const vtkPlusCameraControlParameters& newCameraControlParameters)
+{
+  this->CameraControlParameters->DeepCopy(newCameraControlParameters);
+  if (this->IsConnected() && this->IsRecording())
+  {
+    // If we are connected and recording, apply the new camera control parameters immediately
+    return this->InternalApplyCameraControlParameterChange();
+  }
+}
+
 //----------------------------------------------------------------------------
 PlusStatus vtkPlusMmfVideoSource::InternalApplyCameraControlParameterChange()
 {
diff --git a/src/PlusDataCollection/MicrosoftMediaFoundation/vtkPlusMmfVideoSource.h b/src/PlusDataCollection/MicrosoftMediaFoundation/vtkPlusMmfVideoSource.h
@@ -21,11 +21,13 @@ Authors include: Danielle Pace
 #include "vtkPlusDevice.h"
 #include "vtkIGSIORecursiveCriticalSection.h"
 
+// PlusDataCollection includes
+#include <vtkPlusCameraControlParameters.h>
+
 // VTK includes
 #include <vtkSmartPointer.h>
 
 class MmfVideoSourceReader;
-class vtkPlusCameraControlParameters;
 
 /*!
   \class vtkPlusMmfVideoSource
@@ -73,6 +75,14 @@ class vtkPlusDataCollectionExport vtkPlusMmfVideoSource : public vtkPlusDevice
 
   virtual bool IsTracker() const { return false; }
 
+  /*!
+    Copy the new imaging parameters into the current parameter set
+    It is up to subclasses to take the new imaging parameter set and apply it to their respective devices
+    /param newImagingParameters class containing the new ultrasound imaging parameters
+  */
+  virtual PlusStatus SetNewCameraControlParameters(const vtkPlusCameraControlParameters& newCameraControlParameters);
+  vtkGetObjectMacro(CameraControlParameters, vtkPlusCameraControlParameters);
+
 protected:
   /*! Constructor */
   vtkPlusMmfVideoSource();
diff --git a/src/PlusServer/CMakeLists.txt b/src/PlusServer/CMakeLists.txt
@@ -89,6 +89,17 @@ IF(PLUS_USE_USDIGITALENCODERS_TRACKER)
   LIST(APPEND ${PROJECT_NAME}_HDRS Commands/vtkPlusUSDigitalEncoderCommand.h)
 ENDIF()
 
+IF (PLUS_USE_MMF_VIDEO)
+  LIST(APPEND ${PROJECT_NAME}_SRCS 
+    Commands/vtkPlusSetCameraControlParameterCommand.cxx
+    #Commands/vtkPlusGetCameraControlParameterCommand.cxx
+    )
+  LIST(APPEND ${PROJECT_NAME}_HDRS
+    Commands/vtkPlusSetCameraControlParameterCommand.h
+    #Commands/vtkPlusGetCameraControlParameterCommand.h
+    )
+ENDIF()
+
 SET(${PROJECT_NAME}_INCLUDE_DIRS 
   ${CMAKE_CURRENT_SOURCE_DIR} 
   ${CMAKE_CURRENT_BINARY_DIR} 
diff --git a/src/PlusServer/Commands/vtkPlusSetCameraControlParameterCommand.cxx b/src/PlusServer/Commands/vtkPlusSetCameraControlParameterCommand.cxx
@@ -0,0 +1,304 @@
+/*=Plus=header=begin======================================================
+Program: Plus
+Copyright (c) Laboratory for Percutaneous Surgery. All rights reserved.
+See License.txt for details.
+=========================================================Plus=header=end*/
+
+#include "PlusConfigure.h"
+#include "vtkPlusSetCameraControlParameterCommand.h"
+
+#include "vtkPlusDataCollector.h"
+#include "vtkObjectFactory.h"
+#include "vtkPlusChannel.h"
+#include "vtkPlusCommandProcessor.h"
+#include "vtkPlusCameraControlParameters.h"
+#include "vtkPlusMmfVideoSource.h"
+
+#include <vtkVariant.h>
+#include <vtkSmartPointer.h>
+
+#include <limits>
+#include <iterator>
+#include <string>
+
+namespace
+{
+  static const std::string SET_CAMERA_PARAMETER_CMD = "SetCameraControlParameters";
+}
+
+vtkStandardNewMacro(vtkPlusSetCameraControlParameterCommand);
+
+//----------------------------------------------------------------------------
+vtkPlusSetCameraControlParameterCommand::vtkPlusSetCameraControlParameterCommand()
+{
+  this->CameraDeviceId = "";
+  this->RequestedParameterChanges.clear();
+}
+
+//----------------------------------------------------------------------------
+vtkPlusSetCameraControlParameterCommand::~vtkPlusSetCameraControlParameterCommand()
+{
+  this->RequestedParameterChanges.clear();
+}
+
+//----------------------------------------------------------------------------
+void vtkPlusSetCameraControlParameterCommand::SetNameToSetCameraControlParameter()
+{
+  SetName(SET_CAMERA_PARAMETER_CMD);
+}
+
+//----------------------------------------------------------------------------
+void vtkPlusSetCameraControlParameterCommand::PrintSelf(ostream& os, vtkIndent indent)
+{
+  this->Superclass::PrintSelf(os, indent);
+}
+
+//----------------------------------------------------------------------------
+void vtkPlusSetCameraControlParameterCommand::GetCommandNames(std::list<std::string>& cmdNames)
+{
+  cmdNames.clear();
+  cmdNames.push_back(SET_CAMERA_PARAMETER_CMD);
+}
+
+//----------------------------------------------------------------------------
+std::string vtkPlusSetCameraControlParameterCommand::GetDescription(const std::string& commandName)
+{
+  std::string desc;
+  if (commandName.empty() || igsioCommon::IsEqualInsensitive(commandName, SET_CAMERA_PARAMETER_CMD))
+  {
+    desc += SET_CAMERA_PARAMETER_CMD;
+    desc += ": Set camera image parameter. Attributes: CameraDeviceId: ID of the camera device.";
+  }
+  return desc;
+}
+
+//----------------------------------------------------------------------------
+PlusStatus vtkPlusSetCameraControlParameterCommand::ReadConfiguration(vtkXMLDataElement* aConfig)
+{
+  this->RequestedParameterChanges.clear();
+  if (vtkPlusCommand::ReadConfiguration(aConfig) != PLUS_SUCCESS)
+  {
+    return PLUS_FAIL;
+  }
+
+  this->SetCameraDeviceId(aConfig->GetAttribute("CameraDeviceId"));
+
+  // Parse nested elements and store requested parameter changes
+  for (int elemIndex = 0; elemIndex < aConfig->GetNumberOfNestedElements(); ++elemIndex)
+  {
+    vtkXMLDataElement* currentElem = aConfig->GetNestedElement(elemIndex);
+    if (igsioCommon::IsEqualInsensitive(currentElem->GetName(), "Parameter"))
+    {
+      const char* parameterName = currentElem->GetAttribute("Name");
+      const char* parameterValue = currentElem->GetAttribute("Value");
+      if (!parameterName || !parameterValue)
+      {
+        LOG_ERROR("Unable to find required Name or Value attribute in " << (currentElem->GetName() ? currentElem->GetName() : "(undefined)") << " element in SetUsParameter command");
+        continue;
+      }
+
+      this->RequestedParameterChanges[parameterName] = parameterValue;
+    }
+  }
+
+  return PLUS_SUCCESS;
+}
+
+//----------------------------------------------------------------------------
+PlusStatus vtkPlusSetCameraControlParameterCommand::WriteConfiguration(vtkXMLDataElement* aConfig)
+{
+  if (vtkPlusCommand::WriteConfiguration(aConfig) != PLUS_SUCCESS)
+  {
+    return PLUS_FAIL;
+  }
+
+  XML_WRITE_STRING_ATTRIBUTE_IF_NOT_EMPTY(CameraDeviceId, aConfig);
+
+  // Write parameters as nested elements
+  std::map<std::string, std::string>::iterator paramIt;
+  for (paramIt = this->RequestedParameterChanges.begin(); paramIt != this->RequestedParameterChanges.end(); ++paramIt)
+  {
+    vtkSmartPointer<vtkXMLDataElement> paramElem = vtkSmartPointer<vtkXMLDataElement>::New();
+    paramElem->SetName("Parameter");
+    paramElem->SetAttribute("Name", paramIt->first.c_str());
+    paramElem->SetAttribute("Value", paramIt->second.c_str());
+    aConfig->AddNestedElement(paramElem);
+  }
+
+  return PLUS_SUCCESS;
+}
+
+//----------------------------------------------------------------------------
+PlusStatus vtkPlusSetCameraControlParameterCommand::Execute()
+{
+  LOG_DEBUG("vtkPlusSetCameraControlParameterCommand::Execute: " << (!this->Name.empty() ? this->Name : "(undefined)")
+    << ", device: " << (this->CameraDeviceId.empty() ? "(undefined)" : this->CameraDeviceId));
+
+  if (this->Name.empty())
+  {
+    this->QueueCommandResponse(PLUS_FAIL, "Command failed. See error message.", "No command name specified.");
+    return PLUS_FAIL;
+  }
+  else if (!igsioCommon::IsEqualInsensitive(this->Name, SET_CAMERA_PARAMETER_CMD))
+  {
+    this->QueueCommandResponse(PLUS_FAIL, "Command failed. See error message.", "Unknown command name: " + this->Name + ".");
+    return PLUS_FAIL;
+  }
+
+  vtkPlusMmfVideoSource* cameraDevice = vtkPlusMmfVideoSource::SafeDownCast(this->GetCameraDevice());
+  if (cameraDevice == NULL)
+  {
+    this->QueueCommandResponse(PLUS_FAIL, "Command failed. See error message.", std::string("Device ")
+      + (this->CameraDeviceId.empty() ? "(undefined)" : this->CameraDeviceId) + std::string(" is not found."));
+    return PLUS_FAIL;
+  }
+
+  std::string cameraDeviceId = (cameraDevice->GetDeviceId().empty() ? "(unknown)" : cameraDevice->GetDeviceId());
+  std::string resultString = "<CommandReply>";
+  std::string error = "";
+  std::map < std::string, std::pair<IANA_ENCODING_TYPE, std::string> > metaData;
+  PlusStatus status = PLUS_SUCCESS;
+
+  vtkPlusCameraControlParameters* cameraControlParameters = cameraDevice->GetCameraControlParameters();
+
+  std::map<std::string, std::string>::iterator paramIt;
+  for (paramIt = this->RequestedParameterChanges.begin(); paramIt != this->RequestedParameterChanges.end(); ++paramIt)
+  {
+    std::string parameterName = paramIt->first;
+    std::string value = paramIt->second;
+    resultString += "<Parameter Name=\"" + parameterName + "\"";
+
+    if (parameterName == vtkPlusCameraControlParameters::KEY_AUTO_EXPOSURE
+      || parameterName == vtkPlusCameraControlParameters::KEY_AUTO_FOCUS)
+    {
+      // boolean type parameter
+      bool parameterValue = STRCASECMP(value.c_str(), "true") == 0;
+      cameraControlParameters->SetValue<std::string>(parameterName, parameterValue ? "true" : "false");
+    }
+    else if (parameterName == vtkPlusCameraControlParameters::KEY_PAN_DEGREES
+      || parameterName == vtkPlusCameraControlParameters::KEY_TILT_DEGREES
+      || parameterName == vtkPlusCameraControlParameters::KEY_ROLL_DEGREES
+      || parameterName == vtkPlusCameraControlParameters::KEY_ZOOM_MM
+      || parameterName == vtkPlusCameraControlParameters::KEY_FOCUS_MM)
+    {
+      // double type parameter
+      bool valid = false;
+      double parameterValue = vtkVariant(value).ToDouble(&valid);
+      if (!valid)
+      {
+        error += "Failed to parse " + parameterName + ". ";
+        resultString += " Success=\"false\"/>";
+        metaData[parameterName] = std::make_pair(IANA_TYPE_US_ASCII, "FAIL");
+        status = PLUS_FAIL;
+        continue;
+      }
+      cameraControlParameters->SetValue<double>(parameterName, parameterValue);
+    }
+    else if (parameterName == vtkPlusCameraControlParameters::KEY_EXPOSURE_LOG2SECONDS
+      || parameterName == vtkPlusCameraControlParameters::KEY_IRIS_FSTOP)
+    {
+      // integer type parameter
+      bool valid = false;
+      int parameterValue = vtkVariant(value).ToInt(&valid);
+      if (!valid)
+      {
+        error += "Failed to parse " + parameterName + ". ";
+        resultString += " Success=\"false\"/>";
+        metaData[parameterName] = std::make_pair(IANA_TYPE_US_ASCII, "FAIL");
+        status = PLUS_FAIL;
+        continue;
+      }
+      cameraControlParameters->SetValue<int>(parameterName, parameterValue);
+    }
+    else
+    {
+      error += "Invalid parameter " + parameterName + ". ";
+      resultString += " Success=\"false\"/>";
+      metaData[parameterName] = std::make_pair(IANA_TYPE_US_ASCII, "FAIL");
+      status = PLUS_FAIL;
+      continue;
+    }
+
+    if (cameraDevice->SetNewCameraControlParameters(*cameraControlParameters) == PLUS_FAIL)
+    {
+      error += "Failed to set " + parameterName + ". ";
+      resultString += " Success=\"false\"/>";
+      metaData[parameterName] = std::make_pair(IANA_TYPE_US_ASCII, "FAIL");
+      status = PLUS_FAIL;
+      continue;
+    }
+
+    resultString += " Success=\"true\"/>";
+    metaData[parameterName] = std::make_pair(IANA_TYPE_US_ASCII, "SUCCESS");
+  } // For each parameter
+  resultString += "</CommandReply>";
+
+  if (status != PLUS_SUCCESS)
+  {
+    LOG_WARNING("Failed to set US parameter, result string was: " << resultString);
+  }
+
+  vtkSmartPointer<vtkPlusCommandRTSCommandResponse> commandResponse = vtkSmartPointer<vtkPlusCommandRTSCommandResponse>::New();
+  commandResponse->UseDefaultFormatOff();
+  commandResponse->SetClientId(this->ClientId);
+  commandResponse->SetOriginalId(this->Id);
+  commandResponse->SetDeviceName(this->DeviceName);
+  commandResponse->SetCommandName(this->GetName());
+  commandResponse->SetStatus(status);
+  commandResponse->SetRespondWithCommandMessage(this->RespondWithCommandMessage);
+  commandResponse->SetErrorString(error);
+  commandResponse->SetResultString(resultString);
+  commandResponse->SetParameters(metaData);
+  this->CommandResponseQueue.push_back(commandResponse);
+
+  return status;
+}
+
+//----------------------------------------------------------------------------
+vtkPlusDevice* vtkPlusSetCameraControlParameterCommand::GetCameraDevice()
+{
+  vtkPlusDataCollector* dataCollector = GetDataCollector();
+  if (dataCollector == NULL)
+  {
+    LOG_ERROR("Data collector is invalid");
+    return NULL;
+  }
+  vtkPlusMmfVideoSource* cameraDevice = NULL;
+  if (!this->CameraDeviceId.empty())
+  {
+    // Camera device ID is specified
+    vtkPlusDevice* device = NULL;
+    if (dataCollector->GetDevice(device, this->CameraDeviceId) != PLUS_SUCCESS)
+    {
+      LOG_ERROR("No camera device has been found by the name " << this->CameraDeviceId);
+      return NULL;
+    }
+    // device found
+    cameraDevice = dynamic_cast<vtkPlusMmfVideoSource*>(device);
+    if (cameraDevice == NULL)
+    {
+      // wrong type
+      LOG_ERROR("The specified device " << this->CameraDeviceId << " is not a camera device");
+      return NULL;
+    }
+  }
+  else
+  {
+    // No camera device id is specified, auto-detect the first one and use that
+    for (DeviceCollectionConstIterator it = dataCollector->GetDeviceConstIteratorBegin(); it != dataCollector->GetDeviceConstIteratorEnd(); ++it)
+    {
+      cameraDevice = dynamic_cast<vtkPlusMmfVideoSource*>(*it);
+      if (cameraDevice != NULL)
+      {
+        // found a camera device
+        break;
+      }
+    }
+    if (cameraDevice == NULL)
+    {
+      LOG_ERROR("No camera has been found");
+      return NULL;
+    }
+  }
+  return cameraDevice;
+}
diff --git a/src/PlusServer/Commands/vtkPlusSetCameraControlParameterCommand.h b/src/PlusServer/Commands/vtkPlusSetCameraControlParameterCommand.h
diff --git a/src/PlusServer/vtkPlusCommandProcessor.cxx b/src/PlusServer/vtkPlusCommandProcessor.cxx
