DeviceBase.h

Go to the documentation of this file.

 
// FILE:          DeviceBase.h
// PROJECT:       Micro-Manager
// SUBSYSTEM:     MMDevice - Device adapter kit
//-----------------------------------------------------------------------------
// DESCRIPTION:   Generic functionality for implementing device adapters
//
// AUTHOR:        Nenad Amodaj, nenad@amodaj.com, 08/18/2005
//
// COPYRIGHT:     University of California, San Francisco, 2006
//
// LICENSE:       This file is distributed under the BSD license.
//                License text is included with the source distribution.
//
//                This file is distributed in the hope that it will be useful,
//                but WITHOUT ANY WARRANTY; without even the implied warranty
//                of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//
//                IN NO EVENT SHALL THE COPYRIGHT OWNER OR
//                CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//                INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES.
//
 
#pragma once
 
#include "MMDevice.h"
 
#include "CameraImageMetadata.h"
#include "DeviceThreads.h"
#include "DeviceUtils.h"
#include "MMDeviceConstants.h"
#include "ModuleInterface.h"
#include "Property.h"
 
#include <math.h>
#include <assert.h>
 
#include <string>
#include <vector>
#include <iomanip>
#include <map>
#include <sstream>
#include <utility>
 
// common error messages
const char* const g_Msg_ERR = "Unknown error in the device";
const char* const g_Msg_INVALID_PROPERTY = "Invalid property name encountered";
const char* const g_Msg_INVALID_PROPERTY_VALUE = "Invalid property value";
const char* const g_Msg_DUPLICATE_PROPERTY = "Duplicate property names are not allowed";
const char* const g_Msg_INVALID_PROPERTY_TYPE = "Invalid property type";
const char* const g_Msg_NATIVE_MODULE_FAILED = "Native module failed to load";
const char* const g_Msg_UNSUPPORTED_DATA_FORMAT = "Unsupported data format encountered";
const char* const g_Msg_INTERNAL_INCONSISTENCY = "Device adapter inconsistent with the actual device";
const char* const g_Msg_NOT_SUPPORTED = "Device not supported by the adapter";
const char* const g_Msg_UNKNOWN_LABEL = "Label not defined";
const char* const g_Msg_UNSUPPORTED_COMMAND = "Unsupported device command";
const char* const g_Msg_UNKNOWN_POSITION = "Invalid state (position) requested";
const char* const g_Msg_NO_CALLBACK_REGISTERED = "No callback registered";
const char* const g_Msg_SERIAL_BUFFER_OVERRUN = "Serial buffer overrun.";
const char* const g_Msg_SERIAL_INVALID_RESPONSE = "Unexpected response from serial port. Is the device connected to the correct serial port?";
const char* const g_Msg_SERIAL_TIMEOUT = "Serial timeout occurred.";
const char* const g_Msg_SELF_REFERENCE = "Self reference error.";
const char* const g_Msg_NO_PROPERTY_DATA = "No property data error.";
const char* const g_Msg_DEVICE_DUPLICATE_LABEL = "Position label already in use";
const char* const g_Msg_INVALID_INPUT_PARAM = "Invalid input parameter.";
const char* const g_Msg_BUFFER_OVERFLOW = "Buffer Overflow.";
const char* const g_Msg_SERIAL_COMMAND_FAILED = "Serial command failed.  Is the device connected to the serial port?";
const char* const g_Msg_DEVICE_NONEXISTENT_CHANNEL = "Requested channel is not defined.";
const char* const g_Msg_DEVICE_INVALID_PROPERTY_LIMTS = "Specified property limits are not valid."
" Either the property already has a set of discrete values, or the range is invalid";
const char* const g_Msg_EXCEPTION_IN_THREAD = "Exception in the thread function.";
const char* const g_Msg_EXCEPTION_IN_ON_THREAD_EXITING = "Exception in the OnThreadExiting function.";
const char* const g_Msg_SEQUENCE_ACQUISITION_THREAD_EXITING="Sequence thread exiting";
const char* const g_Msg_DEVICE_CAMERA_BUSY_ACQUIRING="Camera is busy acquiring images.  Stop camera activity before changing this property";
const char* const g_Msg_DEVICE_CAN_NOT_SET_PROPERTY="The device can not set this property at this moment";
const char* const g_Msg_DEVICE_NOT_CONNECTED="Unable to communicate with the device.";
const char* const g_Msg_DEVICE_COMM_HUB_MISSING= "Parent module (Hub) is not available or defined for this device!";
const char* const g_Msg_DEVICE_DUPLICATE_LIBRARY="Duplicate Device Library Name";
const char* const g_Msg_DEVICE_PROPERTY_NOT_SEQUENCEABLE="This property is not sequenceable";
const char* const g_Msg_DEVICE_SEQUENCE_TOO_LARGE="Sequence is too large for this device";
const char* const g_Msg_DEVICE_NOT_YET_IMPLEMENTED="This command has not yet been implemented for this device.";
 
inline long nint( double value )
{
   return (long)floor( 0.5 + value);
};
 
template <class T, class U>
class CDeviceBase : public T
{
public:
 
   typedef MM::Action<U> CPropertyAction;
   typedef MM::ActionEx<U> CPropertyActionEx;
 
   virtual void SetModuleName(const char* name)
   {
      moduleName_ = name;
   }
 
   virtual void GetModuleName(char* name) const
   {
      CDeviceUtils::CopyLimitedString(name, moduleName_.c_str());
   }
 
   virtual void SetDescription(const char* descr)
   {
      description_ = descr;
   }
 
   virtual void GetDescription(char* name) const
   {
      CDeviceUtils::CopyLimitedString(name, description_.c_str());
   }
 
   virtual void SetLabel(const char* label)
   {
      label_ = label;
   }
 
   virtual void GetLabel(char* name) const
   {
      CDeviceUtils::CopyLimitedString(name, label_.c_str());
   }
 
   virtual double GetDelayMs() const {return delayMs_;}
 
   virtual void SetDelayMs(double delay) {delayMs_ = delay;}
 
   virtual void SetCallback(MM::Core* cbk) {callback_ = cbk;}
 
   virtual bool UsesDelay() {return usesDelay_;}
 
   virtual unsigned GetNumberOfProperties() const {return (unsigned)properties_.GetSize();}
 
   virtual int GetProperty(const char* name, char* value) const
   {
      std::string strVal;
      // additional information for reporting invalid properties.
      SetMorePropertyErrorInfo(name);
      int nRet = properties_.Get(name, strVal);
      if (nRet == DEVICE_OK)
         CDeviceUtils::CopyLimitedString(value, strVal.c_str());
      return nRet;
   }
 
   int GetProperty(const char* name, double& val)
   {
      std::string strVal;
      int nRet = properties_.Get(name, strVal);
      if (nRet == DEVICE_OK)
         val = atof(strVal.c_str());
      return nRet;
   }
 
   int GetProperty(const char* name, long& val)
   {
      std::string strVal;
      int nRet = properties_.Get(name, strVal);
      if (nRet == DEVICE_OK)
         val = atol(strVal.c_str());
      return nRet;
   }
 
   bool IsPropertyEqualTo(const char* name, const char* val) const
   {
      std::string strVal;
      int nRet = properties_.Get(name, strVal);
      if (nRet == DEVICE_OK)
         return strcmp(val, strVal.c_str()) == 0;
      else
         return false;
   }
 
   virtual int GetPropertyReadOnly(const char* name, bool& readOnly) const
   {
      MM::Property* pProp = properties_.Find(name);
      if (!pProp)
      {
         // additional information for reporting invalid properties.
         SetMorePropertyErrorInfo(name);
         return DEVICE_INVALID_PROPERTY;
      }
      readOnly = pProp->GetReadOnly();
 
      return DEVICE_OK;
   }
 
   virtual int GetPropertyInitStatus(const char* name, bool& preInit) const
   {
      MM::Property* pProp = properties_.Find(name);
      if (!pProp)
      {
         // additional information for reporting invalid properties.
         SetMorePropertyErrorInfo(name);
         return DEVICE_INVALID_PROPERTY;
      }
      preInit = pProp->GetInitStatus();
 
      return DEVICE_OK;
   }
 
   virtual int HasPropertyLimits(const char* name, bool& hasLimits) const
   {
      MM::Property* pProp = properties_.Find(name);
      if (!pProp)
      {
         // additional information for reporting invalid properties.
         SetMorePropertyErrorInfo(name);
         return DEVICE_INVALID_PROPERTY;
      }
      hasLimits = pProp->HasLimits();
      return DEVICE_OK;
   }
 
   virtual int GetPropertyLowerLimit(const char* name, double& lowLimit) const
   {
      MM::Property* pProp = properties_.Find(name);
      if (!pProp)
      {
         // additional information for reporting invalid properties.
         SetMorePropertyErrorInfo(name);
         return DEVICE_INVALID_PROPERTY;
      }
      lowLimit = pProp->GetLowerLimit();
      return DEVICE_OK;
   }
 
   virtual int GetPropertyUpperLimit(const char* name, double& hiLimit) const
   {
      MM::Property* pProp = properties_.Find(name);
      if (!pProp)
      {
         // additional information for reporting invalid properties.
         SetMorePropertyErrorInfo(name);
         return DEVICE_INVALID_PROPERTY;
      }
      hiLimit = pProp->GetUpperLimit();
      return DEVICE_OK;
   }
 
   virtual int IsPropertySequenceable(const char* name, bool& sequenceable) const
   {
      MM::Property* pProp = properties_.Find(name);
      if (!pProp)
      {
         // additional information for reporting invalid properties.
         SetMorePropertyErrorInfo(name);
         return DEVICE_INVALID_PROPERTY;
      }
      sequenceable = pProp->IsSequenceable();
 
      return DEVICE_OK;
   }
 
   virtual int GetPropertySequenceMaxLength(const char* name, long& nrEvents) const
   {
      MM::Property* pProp = properties_.Find(name);
      if (!pProp)
      {
         // additional information for reporting invalid properties.
         SetMorePropertyErrorInfo(name);
         return DEVICE_INVALID_PROPERTY;
      }
      bool sequenceable;
      int ret = IsPropertySequenceable(name, sequenceable);
      if (ret != DEVICE_OK)
         return ret;
      if (!sequenceable) {
         SetMorePropertyErrorInfo(name);
         return DEVICE_PROPERTY_NOT_SEQUENCEABLE;
      }
 
      nrEvents = pProp->GetSequenceMaxSize();
 
      return DEVICE_OK;
   }
 
   virtual int StartPropertySequence(const char* name)
   {
      MM::Property* pProp = properties_.Find(name);
      if (!pProp)
      {
         // additional information for reporting invalid properties.
         SetMorePropertyErrorInfo(name);
         return DEVICE_INVALID_PROPERTY;
      }
      bool sequenceable;
      int ret = IsPropertySequenceable(name, sequenceable);
      if (ret != DEVICE_OK)
         return ret;
      if (!sequenceable) {
         SetMorePropertyErrorInfo(name);
         return DEVICE_PROPERTY_NOT_SEQUENCEABLE;
      }
 
      return pProp->StartSequence();
   }
 
   virtual int StopPropertySequence(const char* name)
   {
      MM::Property* pProp = properties_.Find(name);
      if (!pProp)
      {
         SetMorePropertyErrorInfo(name);
         return DEVICE_INVALID_PROPERTY;
      }
      bool sequenceable;
      int ret = IsPropertySequenceable(name, sequenceable);
      if (ret != DEVICE_OK)
         return ret;
      if (!sequenceable) {
         SetMorePropertyErrorInfo(name);
         return DEVICE_PROPERTY_NOT_SEQUENCEABLE;
      }
 
      return pProp->StopSequence();
   }
 
   virtual int ClearPropertySequence(const char* name)
   {
      MM::Property* pProp;
      int ret = GetSequenceableProperty(&pProp, name);
      if (ret != DEVICE_OK)
         return ret;
 
      return pProp->ClearSequence();
   }
 
   virtual int AddToPropertySequence(const char* name, const char* value)
   {
      MM::Property* pProp;
      int ret = GetSequenceableProperty(&pProp, name);
      if (ret != DEVICE_OK)
         return ret;
 
      return pProp->AddToSequence(value);
   }
 
   virtual int SendPropertySequence(const char* name)
   {
      MM::Property* pProp;
      int ret = GetSequenceableProperty(&pProp, name);
      if (ret != DEVICE_OK)
         return ret;
 
      return pProp->SendSequence();
   }
 
   virtual bool GetPropertyName(unsigned uIdx, char* name) const
   {
      std::string strName;
      if (!properties_.GetName(uIdx, strName))
         return false;
 
      CDeviceUtils::CopyLimitedString(name, strName.c_str());
      return true;
   }
 
   virtual int GetPropertyType(const char* name, MM::PropertyType& pt) const
   {
      MM::Property* pProp = properties_.Find(name);
      if (!pProp)
         return DEVICE_INVALID_PROPERTY;
 
      pt = pProp->GetType();
      return DEVICE_OK;
   }
 
   virtual int SetProperty(const char* name, const char* value)
   {
      int ret = properties_.Set(name, value);
      if( DEVICE_OK != ret)
      {
         // additional information for reporting invalid properties.
         SetMorePropertyErrorInfo(name);
 
      }
      return ret;
   }
 
   virtual bool HasProperty(const char* name) const
   {
      MM::Property* pProp = properties_.Find(name);
      if (pProp)
         return true;
      else
         return false;
   }
 
   virtual unsigned GetNumberOfPropertyValues(const char* propertyName) const
   {
      MM::Property* pProp = properties_.Find(propertyName);
      if (!pProp)
         return 0;
 
      return (unsigned)pProp->GetAllowedValues().size();
   }
 
   virtual bool GetPropertyValueAt(const char* propertyName, unsigned index, char* value) const
   {
      MM::Property* pProp = properties_.Find(propertyName);
      if (!pProp)
         return false;
 
      std::vector<std::string> values = pProp->GetAllowedValues();
      if (values.size() < index)
         return false;
 
      CDeviceUtils::CopyLimitedString(value, values[index].c_str());
      return true;
   }
 
   int CreateProperty(const char* name, const char* value, MM::PropertyType eType, bool readOnly, MM::ActionFunctor* pAct=0, bool isPreInitProperty=false)
   {
      return properties_.CreateProperty(name, value, eType, readOnly, pAct, isPreInitProperty);
   }
 
   int CreatePropertyWithHandler(const char* name, const char* value, MM::PropertyType eType, bool readOnly,
                                 int(U::*memberFunction)(MM::PropertyBase* pProp, MM::ActionType eAct), bool isPreInitProperty=false) {
      CPropertyAction* pAct = new CPropertyAction((U*) this, memberFunction);
      return CreateProperty(name, value, eType, readOnly, pAct, isPreInitProperty);
   }
 
   int CreateIntegerProperty(const char* name, long value, bool readOnly, MM::ActionFunctor* pAct = 0, bool isPreInitProperty = false)
   {
      // Note: in theory, we can avoid converting to string and back. At this
      // moment, it is not worth the trouble.
      std::ostringstream oss;
      oss << value;
      return CreateProperty(name, oss.str().c_str(), MM::Integer, readOnly, pAct, isPreInitProperty);
   }
 
   int CreateFloatProperty(const char* name, double value, bool readOnly, MM::ActionFunctor* pAct = 0, bool isPreInitProperty = false)
   {
      // Note: in theory, we can avoid converting to string and back. At this
      // moment, it is not worth the trouble.
      //
      // However, note the following assumption being made here: the default
      // settings of std::ostream will return strings with a decimal precision
      // of 6 digits. When this eventually gets passed to
      // MM::FloatProperty::Set(double), it gets truncated to 4 digits before
      // being stored. Thus, we do not loose any information.
      std::ostringstream oss;
      oss << value;
      return CreateProperty(name, oss.str().c_str(), MM::Float, readOnly, pAct, isPreInitProperty);
   }
 
   int CreateStringProperty(const char* name, const char* value, bool readOnly, MM::ActionFunctor* pAct = 0, bool isPreInitProperty = false)
   {
      return CreateProperty(name, value, MM::String, readOnly, pAct, isPreInitProperty);
   }
 
   int SetPropertyLimits(const char* name, double low, double high)
   {
      MM::Property* pProp = properties_.Find(name);
      if (!pProp)
      {
         SetMorePropertyErrorInfo(name);
         return DEVICE_INVALID_PROPERTY;
      }
      if (pProp->SetLimits(low, high))
         return DEVICE_OK;
      else {
         std::ostringstream os;
         os << "Device adapter requests invalid values ( " << low << ", ";
         os << high << ") for property: " << name;
         LogMessage(os.str().c_str(), false);
         return DEVICE_INVALID_PROPERTY_LIMTS;
      }
   }
 
   int SetAllowedValues(const char* name, std::vector<std::string>& values)
   {
      return properties_.SetAllowedValues(name, values);
   }
 
   int ClearAllowedValues(const char* name)
   {
      return properties_.ClearAllowedValues(name);
   }
 
   int AddAllowedValue(const char* name, const char* value)
   {
      return properties_.AddAllowedValue(name, value);
   }
 
   int AddAllowedValue(const char* name, const char* value, long data)
   {
      return properties_.AddAllowedValue(name, value, data);
   }
 
   int GetPropertyData(const char* name, const char* value, long& data)
   {
      int ret = properties_.GetPropertyData(name, value, data);
      if( DEVICE_OK != ret)
        // additional information for reporting invalid properties.
         SetMorePropertyErrorInfo(name);
 
      return ret;
   }
 
   int GetCurrentPropertyData(const char* name, long& data)
   {
      int ret = properties_.GetCurrentPropertyData(name, data);
      if( DEVICE_OK != ret)
        // additional information for reporting invalid properties.
         SetMorePropertyErrorInfo(name);
 
      return ret;
   }
 
   int UpdateStatus()
   {
      return properties_.UpdateAll();
   }
 
   int UpdateProperty(const char* name)
   {
      return properties_.Update(name);
   }
 
 
   int ApplyProperty(const char* name)
   {
      return properties_.Apply(name);
   }
 
   virtual bool GetErrorText(int errorCode, char* text) const
   {
      std::map<int, std::string>::const_iterator it;
      it = messages_.find(errorCode);
      if (it == messages_.end())
      {
         // generic message
         std::ostringstream osTxt;
         osTxt << "Error code " << errorCode << " (" << std::setbase(16) << errorCode << " hex)";
         CDeviceUtils::CopyLimitedString(text, osTxt.str().c_str());
         return false; // message text not found
      }
      else
      {
         std::ostringstream stringStreamMessage;
         stringStreamMessage << it->second.c_str();
         // add the additional 'property' error info.
         if( 2<=errorCode && errorCode<=5 )
         {
            stringStreamMessage << ": " << GetMorePropertyErrorInfo();
         }
         SetMorePropertyErrorInfo("");
         // native message
         CDeviceUtils::CopyLimitedString(text, stringStreamMessage.str().c_str());
         return true; // message found
      }
   }
 
   // device discovery (auto-configuration)
   virtual bool SupportsDeviceDetection(void) {
       return false;
   }
   virtual MM::DeviceDetectionStatus DetectDevice(void){
      return  MM::Unimplemented;
   };
 
   // hub - peripheral relationship
   virtual void SetParentID(const char* parentId)
   {
      parentID_ = parentId;
 
      // truncate if necessary
      if (parentID_.size() >= (unsigned) MM::MaxStrLength)
         parentID_ = parentID_.substr(MM::MaxStrLength-1);
 
      if (this->HasProperty(MM::g_Keyword_HubID))
      {
         this->SetProperty(MM::g_Keyword_HubID, parentID_.c_str());
      }
   }
 
   virtual void GetParentID(char* parentID) const
   {
      CDeviceUtils::CopyLimitedString(parentID, parentID_.c_str());
   }
 
   // Protected methods, for internal use by the device adapters
 
protected:
 
   CDeviceBase() : delayMs_(0), usesDelay_(false), callback_(0)
   {
      InitializeDefaultErrorMessages();
   }
   virtual ~CDeviceBase() {}
 
   void SetErrorText(int errorCode, const char* text)
   {
      messages_[errorCode] = text;
   }
 
   const char* GetMorePropertyErrorInfo(void) const
   {
      return morePropertyErrorInfo_.c_str();
   }
 
   void SetMorePropertyErrorInfo( const char* ptext) const
   {
      morePropertyErrorInfo_ = ptext;
   }
 
   int LogMessage(const char* msg, bool debugOnly = false) const
   {
      if (callback_)
         return callback_->LogMessage(this, msg, debugOnly);
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   int LogMessage(const std::string& msg, bool debugOnly = false) const
   {
      if (callback_)
         return callback_->LogMessage(this, msg.c_str(), debugOnly);
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   int LogMessageCode(const int errorCode, bool debugOnly = false) const
   {
      if (callback_)
      {
         char text[MM::MaxStrLength];
         GetErrorText(errorCode, text);
         return callback_->LogMessage(this, text, debugOnly);
      }
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
 
   int LogTimeDiff(MM::MMTime start, MM::MMTime end, const std::string& message, bool debugOnly = false) const
   {
      std::ostringstream os;
      MM::MMTime t = end-start;
      os << message << t.toString() << " seconds";
      if (callback_)
         return callback_->LogMessage(this, os.str().c_str(), debugOnly);
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   int LogTimeDiff(MM::MMTime start, MM::MMTime end, bool debugOnly = false) const
   {
      return LogTimeDiff(start, end, "Process took: " , debugOnly);
   }
 
   void InitializeDefaultErrorMessages()
   {
      // initialize error codes
      SetErrorText(DEVICE_ERR, g_Msg_ERR);
      SetErrorText(DEVICE_INVALID_PROPERTY, g_Msg_INVALID_PROPERTY);
      SetErrorText(DEVICE_INVALID_PROPERTY_VALUE, g_Msg_INVALID_PROPERTY_VALUE);
      SetErrorText(DEVICE_DUPLICATE_PROPERTY, g_Msg_DUPLICATE_PROPERTY);
      SetErrorText(DEVICE_INVALID_PROPERTY_TYPE, g_Msg_INVALID_PROPERTY_TYPE);
      SetErrorText(DEVICE_NATIVE_MODULE_FAILED, g_Msg_NATIVE_MODULE_FAILED);
      SetErrorText(DEVICE_UNSUPPORTED_DATA_FORMAT, g_Msg_UNSUPPORTED_DATA_FORMAT);
      SetErrorText(DEVICE_INTERNAL_INCONSISTENCY, g_Msg_INTERNAL_INCONSISTENCY);
      SetErrorText(DEVICE_NOT_SUPPORTED, g_Msg_NOT_SUPPORTED);
      SetErrorText(DEVICE_UNKNOWN_LABEL, g_Msg_UNKNOWN_LABEL);
      SetErrorText(DEVICE_UNSUPPORTED_COMMAND, g_Msg_UNSUPPORTED_COMMAND);
      SetErrorText(DEVICE_UNKNOWN_POSITION, g_Msg_UNKNOWN_POSITION);
      SetErrorText(DEVICE_NO_CALLBACK_REGISTERED, g_Msg_NO_CALLBACK_REGISTERED);
      SetErrorText(DEVICE_SERIAL_COMMAND_FAILED, g_Msg_SERIAL_COMMAND_FAILED);
      SetErrorText(DEVICE_SERIAL_BUFFER_OVERRUN, g_Msg_SERIAL_BUFFER_OVERRUN);
      SetErrorText(DEVICE_SERIAL_INVALID_RESPONSE, g_Msg_SERIAL_INVALID_RESPONSE);
      SetErrorText(DEVICE_SERIAL_TIMEOUT, g_Msg_SERIAL_TIMEOUT);
      SetErrorText(DEVICE_SELF_REFERENCE, g_Msg_SELF_REFERENCE);
      SetErrorText(DEVICE_NO_PROPERTY_DATA, g_Msg_NO_PROPERTY_DATA);
      SetErrorText(DEVICE_DUPLICATE_LABEL, g_Msg_DEVICE_DUPLICATE_LABEL);
      SetErrorText(DEVICE_INVALID_INPUT_PARAM, g_Msg_INVALID_INPUT_PARAM);
      SetErrorText(DEVICE_BUFFER_OVERFLOW, g_Msg_BUFFER_OVERFLOW);
      SetErrorText(DEVICE_NONEXISTENT_CHANNEL, g_Msg_DEVICE_NONEXISTENT_CHANNEL);
      SetErrorText(DEVICE_INVALID_PROPERTY_LIMTS, g_Msg_DEVICE_INVALID_PROPERTY_LIMTS);
      SetErrorText(DEVICE_CAMERA_BUSY_ACQUIRING, g_Msg_DEVICE_CAMERA_BUSY_ACQUIRING);
      SetErrorText(DEVICE_CAN_NOT_SET_PROPERTY, g_Msg_DEVICE_CAN_NOT_SET_PROPERTY);
      SetErrorText(DEVICE_LOCALLY_DEFINED_ERROR, "t.b.d.");
      SetErrorText(DEVICE_NOT_CONNECTED, g_Msg_DEVICE_NOT_CONNECTED);
      SetErrorText(DEVICE_COMM_HUB_MISSING, g_Msg_DEVICE_COMM_HUB_MISSING);
      SetErrorText(DEVICE_DUPLICATE_LIBRARY, g_Msg_DEVICE_DUPLICATE_LIBRARY);
      SetErrorText(DEVICE_PROPERTY_NOT_SEQUENCEABLE, g_Msg_DEVICE_PROPERTY_NOT_SEQUENCEABLE);
      SetErrorText(DEVICE_SEQUENCE_TOO_LARGE, g_Msg_DEVICE_SEQUENCE_TOO_LARGE);
      SetErrorText(DEVICE_NOT_YET_IMPLEMENTED, g_Msg_DEVICE_NOT_YET_IMPLEMENTED);
   }
 
   MM::Device* GetDevice(const char* deviceLabel) const
   {
      if (callback_)
         return callback_->GetDevice(this, deviceLabel);
      return 0;
   }
 
   // Microsoft compiler has trouble generating code to transport stl objects across DLL boundary
   // so we use char*. Other compilers could conceivably have similar trouble, if for example,
   // a dynamic library is linked with a different CRT than its client.
   void GetLoadedDeviceOfType(MM::DeviceType devType, char* deviceName, const unsigned int deviceIterator )
   {
      deviceName[0] = 0;
      if (callback_)
      {
         callback_->GetLoadedDeviceOfType( this, devType, deviceName, deviceIterator);
      }
   }
 
 
   int WriteToComPort(const char* portLabel, const unsigned char* buf, unsigned bufLength)
   {
      if (callback_)
         return callback_->WriteToSerial(this, portLabel, buf, bufLength);
 
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   int SendSerialCommand(const char* portName, const char* command, const char* term)
   {
      if (callback_)
         return callback_->SetSerialCommand(this, portName, command, term);
 
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   int GetSerialAnswer (const char* portName, const char* term, std::string& ans)
   {
      const unsigned long MAX_BUFLEN = 2000;
      char buf[MAX_BUFLEN];
      if (callback_)
      {
         int ret = callback_->GetSerialAnswer(this, portName, MAX_BUFLEN, buf, term);
         if (ret != DEVICE_OK)
            return ret;
         ans = buf;
         return DEVICE_OK;
      }
 
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   int ReadFromComPort(const char* portLabel, unsigned char* buf, unsigned bufLength, unsigned long& read)
   {
      if (callback_)
         return callback_->ReadFromSerial(this, portLabel, buf, bufLength, read);
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   int PurgeComPort(const char* portLabel)
   {
      if (callback_)
         return callback_->PurgeSerial(this, portLabel);
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   MM::PortType GetSerialPortType(const char* portLabel)
   {
      if (callback_)
         return callback_->GetSerialPortType(portLabel);
      return MM::InvalidPort;
   }
 
   int OnPropertiesChanged()
   {
      if (callback_)
         return callback_->OnPropertiesChanged(this);
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   int OnPropertyChanged(const char* propName, const char* propValue)
   {
      if (callback_)
         return callback_->OnPropertyChanged(this, propName, propValue);
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   int OnStagePositionChanged(double pos)
   {
      if (callback_)
         return callback_->OnStagePositionChanged(this, pos);
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   int OnXYStagePositionChanged(double xPos, double yPos)
   {
      if (callback_)
         return callback_->OnXYStagePositionChanged(this, xPos, yPos);
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   int OnExposureChanged(double exposure)
   {
      if (callback_)
         return callback_->OnExposureChanged(this, exposure);
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   int OnSLMExposureChanged(double exposure)
   {
      if (callback_)
         return callback_->OnSLMExposureChanged(this, exposure);
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   int OnMagnifierChanged()
   {
      if (callback_)
         return callback_->OnMagnifierChanged(this);
      return DEVICE_NO_CALLBACK_REGISTERED;
   }
 
   unsigned long GetClockTicksUs()
   {
      if (callback_)
         return callback_->GetClockTicksUs(this);
 
      return 0;
   }
 
   MM::MMTime GetCurrentMMTime()
   {
      if (callback_)
         return callback_->GetCurrentMMTime();
 
      return MM::MMTime(0.0);
   }
 
   bool IsCallbackRegistered() const
   {
      return callback_ == 0 ? false : true;
   }
 
   MM::Core* GetCoreCallback() const
   {
      return callback_;
   }
 
   void EnableDelay(bool state = true)
   {
      usesDelay_ = state;
   }
 
   void CreateHubIDProperty()
   {
      char pid[MM::MaxStrLength];
      this->GetParentID(pid);
      this->CreateProperty(MM::g_Keyword_HubID, pid, MM::String, true);
   }
 
   MM::Hub* GetParentHub() const
   {
      if (IsCallbackRegistered())
         return GetCoreCallback()->GetParentHub(this);
 
      return 0;
   }
 
   template<class T_HUB>
   T_HUB* AssignToHub() {
      T_HUB* hub = static_cast<T_HUB*>(GetParentHub());
      if (hub == NULL) {
         LogMessage("Parent hub not defined.");
      } else {
         char hubLabel[MM::MaxStrLength];
         hub->GetLabel(hubLabel);
         SetParentID(hubLabel); // for backward comp.
      }
      return hub;
   }
 
private:
   bool PropertyDefined(const char* propName) const
   {
      return properties_.Find(propName) != 0;
   }
 
   int GetSequenceableProperty(MM::Property** pProp, const char* name) const
   {
      *pProp = properties_.Find(name);
      if (!*pProp)
      {
         SetMorePropertyErrorInfo(name);
         return DEVICE_INVALID_PROPERTY;
      }
 
      bool sequenceable = (*pProp)->IsSequenceable();
      if (!sequenceable) {
         SetMorePropertyErrorInfo(name);
         return DEVICE_PROPERTY_NOT_SEQUENCEABLE;
      }
      return DEVICE_OK;
   }
 
 
   MM::PropertyCollection properties_;
   std::string label_;
   std::string moduleName_;
   std::string description_;
   std::map<int, std::string> messages_;
   double delayMs_;
   bool usesDelay_;
   MM::Core* callback_;
   // specific information about the errant property, etc.
   mutable std::string morePropertyErrorInfo_;
   std::string parentID_;
};
 
// Forbid instantiation of CDeviceBase<MM::Device, U>
// (It was abused in the past.)
template <class U>
class CDeviceBase<MM::Device, U>
{
   CDeviceBase(); // private; construction disallowed
};
 
template <class U>
class CGenericBase : public CDeviceBase<MM::Generic, U>
{
};
 
 
template <class U>
class CCameraBase : public CDeviceBase<MM::Camera, U>
{
public:
   // These 2 'using' declarations were originally introduced in order to allow
   // C[Legacy]CameraBase member functions to call these functions (which would
   // have also been possible with 'this->'). The 2 functions are protected in
   // CDeviceBase. However, they are made public here, and some concrete
   // cameras ended up depending on that. So they need to be kept for now,
   // until and unless such cameras are fixed.
   using CDeviceBase<MM::Camera, U>::GetCoreCallback;
   using CDeviceBase<MM::Camera, U>::LogMessage;
 
   CCameraBase()
   {
      // create and initialize common transpose properties
      std::vector<std::string> allowedValues;
      allowedValues.push_back("0");
      allowedValues.push_back("1");
      this->CreateProperty(MM::g_Keyword_Transpose_SwapXY, "0", MM::Integer, false);
      this->SetAllowedValues(MM::g_Keyword_Transpose_SwapXY, allowedValues);
      this->CreateProperty(MM::g_Keyword_Transpose_MirrorX, "0", MM::Integer, false);
      this->SetAllowedValues(MM::g_Keyword_Transpose_MirrorX, allowedValues);
      this->CreateProperty(MM::g_Keyword_Transpose_MirrorY, "0", MM::Integer, false);
      this->SetAllowedValues(MM::g_Keyword_Transpose_MirrorY, allowedValues);
      this->CreateProperty(MM::g_Keyword_Transpose_Correction, "0", MM::Integer, false);
      this->SetAllowedValues(MM::g_Keyword_Transpose_Correction, allowedValues);
 
   }
 
   virtual const unsigned char* GetImageBuffer() = 0;
   virtual unsigned GetImageWidth() const = 0;
   virtual unsigned GetImageHeight() const = 0;
   virtual unsigned GetImageBytesPerPixel() const = 0;
   virtual int SnapImage() = 0;
   virtual bool Busy() = 0;
 
   virtual int StartSequenceAcquisition(double interval) = 0;
 
   virtual int StopSequenceAcquisition() = 0;
 
   virtual unsigned GetNumberOfComponents() const
   {
      return 1; // Default to monochrome (ie not RGB)
   }
 
   virtual unsigned GetNumberOfChannels() const
   {
      return 1;
   }
 
   virtual int GetChannelName(unsigned /* channel */, char* name)
   {
      CDeviceUtils::CopyLimitedString(name, "");
      return DEVICE_OK;
   }
 
   virtual const unsigned char* GetImageBuffer(unsigned /* channelNr */)
   {
      if (GetNumberOfChannels() == 1)
         return GetImageBuffer();
      return 0;
   }
 
   virtual const unsigned int* GetImageBufferAsRGB32()
   {
      return 0;
   }
 
   virtual void GetTags(char* serializedMetadata)
   {
      MM::CameraImageMetadata md;
      for (const auto& p : addedTags_)
      {
         md.AddTag(p.first.c_str(), p.second.c_str());
      }
      CDeviceUtils::CopyLimitedString(serializedMetadata, md.Serialize());
   }
 
   virtual int StartSequenceAcquisition(long numImages, double interval_ms,
                              bool stopOnOverflow) = 0;
 
   virtual int GetExposureSequenceMaxLength(long& /*nrEvents*/) const
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int StartExposureSequence()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int StopExposureSequence()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int ClearExposureSequence()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int AddToExposureSequence(double /*exposureTime_ms*/)
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int SendExposureSequence() const
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual bool IsCapturing() = 0;
 
   virtual void AddTag(const char* key, const char* deviceLabel, const char* value)
   {
      std::string k;
      if (deviceLabel != std::string("_"))
      {
         k += deviceLabel;
         k += '-';
      }
      k += key;
      addedTags_[k] = value;
   }
 
   virtual void RemoveTag(const char* key)
   {
      addedTags_.erase(key);
   }
 
   virtual bool SupportsMultiROI()
   {
      return false;
   }
 
   virtual bool IsMultiROISet()
   {
      return false;
   }
 
   virtual int GetMultiROICount(unsigned& /* count */)
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int SetMultiROI(const unsigned* /* xs */, const unsigned* /* ys */,
         const unsigned* /* widths */, const unsigned* /* heights */,
         unsigned /* numROIs */)
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int GetMultiROI(unsigned* /* xs */, unsigned* /* ys */,
         unsigned* /* widths */, unsigned* /* heights */, unsigned* /* length */)
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
private:
   std::map<std::string, std::string> addedTags_;
};
 
 
 
 
template <class U>
class CLegacyCameraBase : public CCameraBase<U>
{
public:
   CLegacyCameraBase() : busy_(false), stopWhenCBOverflows_(false), thd_(0)
   {
      thd_ = new BaseSequenceThread(this);
   }
 
   virtual ~CLegacyCameraBase()
   {
      if (!thd_->IsStopped()) {
         thd_->Stop();
         thd_->wait();
      }
      delete thd_;
   }
 
 
   virtual bool Busy() {return busy_;}
 
   virtual int StartSequenceAcquisition(double interval)
   {
      return StartSequenceAcquisition(LONG_MAX, interval, false);
   }
 
   virtual int StopSequenceAcquisition()
   {
      if (!thd_->IsStopped()) {
         thd_->Stop();
         thd_->wait();
      }
 
      return DEVICE_OK;
   }
 
   // Implementation of a sequence acquisition as a series of snaps
   // This was a temporary method used for debugging, which is why its now
   // implemented in this legacy class. It's preferable that camera devices
   // inherit directly from CCameraBase and not use these default implementations.   
   virtual int StartSequenceAcquisition(long numImages, double interval_ms, bool stopOnOverflow)
   {
      if (IsCapturing())
         return DEVICE_CAMERA_BUSY_ACQUIRING;
 
      int ret = this->GetCoreCallback()->PrepareForAcq(this);
      if (ret != DEVICE_OK)
         return ret;
      thd_->Start(numImages,interval_ms);
      stopWhenCBOverflows_ = stopOnOverflow;
      return DEVICE_OK;
   }
 
   virtual bool IsCapturing(){return !thd_->IsStopped();}
 
 
protected:
   // Member functions that can be overridden by derived classes (these
   // customize the legacy snap-based sequence acquisition).
 
   // Do actual capturing
   // Called from inside the thread
   virtual int ThreadRun (void)
   {
      int ret=DEVICE_ERR;
      ret = this->SnapImage();
      if (ret != DEVICE_OK)
      {
         return ret;
      }
      ret = InsertImage();
      if (ret != DEVICE_OK)
      {
         return ret;
      }
      return ret;
   };
 
   virtual int InsertImage()
   {
      char label[MM::MaxStrLength];
      this->GetLabel(label);
      MM::CameraImageMetadata md;
      md.AddTag(MM::g_Keyword_Metadata_CameraLabel, label);
      return this->GetCoreCallback()->InsertImage(this, this->GetImageBuffer(), this->GetImageWidth(),
         this->GetImageHeight(), this->GetImageBytesPerPixel(),
         md.Serialize());
   }
 
   virtual double GetIntervalMs() {return thd_->GetIntervalMs();}
   virtual long GetImageCounter() {return thd_->GetImageCounter();}
   virtual long GetNumberOfImages() {return thd_->GetNumberOfImages();}
 
   // called from the thread function before exit
   virtual void OnThreadExiting()
   {
      try
      {
         this->LogMessage(g_Msg_SEQUENCE_ACQUISITION_THREAD_EXITING);
         if (this->GetCoreCallback() != nullptr) {
            this->GetCoreCallback()->AcqFinished(this, 0);
         }
      }
      catch(...)
      {
         this->LogMessage(g_Msg_EXCEPTION_IN_ON_THREAD_EXITING, false);
      }
   }
 
   virtual bool isStopOnOverflow() {return stopWhenCBOverflows_;}
   virtual void setStopOnOverflow(bool stop) {stopWhenCBOverflows_ = stop;}
 
   // Helper Class
   class CaptureRestartHelper
   {
      bool restart_;
      CLegacyCameraBase* pCam_;
 
   public:
      CaptureRestartHelper(CLegacyCameraBase* pCam)
         :pCam_(pCam)
      {
         restart_=pCam_->IsCapturing();
      }
      operator bool()
      {
         return restart_;
      }
   };
 
   // Nested class for live streaming
   class BaseSequenceThread : public MMDeviceThreadBase
   {
      friend class CLegacyCameraBase;
      enum { default_numImages=1, default_intervalMS = 100 };
   public:
      BaseSequenceThread(CLegacyCameraBase* pCam)
         :intervalMs_(default_intervalMS)
         ,numImages_(default_numImages)
         ,imageCounter_(0)
         ,stop_(true)
         ,suspend_(false)
         ,camera_(pCam)
         ,startTime_(0)
         ,actualDuration_(0)
         ,lastFrameTime_(0)
      {};
 
      ~BaseSequenceThread() {}
 
      void Stop() {
         MMThreadGuard g(this->stopLock_);
         stop_=true;
      }
 
      void Start(long numImages, double intervalMs)
      {
         MMThreadGuard g1(this->stopLock_);
         MMThreadGuard g2(this->suspendLock_);
         numImages_=numImages;
         intervalMs_=intervalMs;
         imageCounter_=0;
         stop_ = false;
         suspend_=false;
         activate();
         actualDuration_ = MM::MMTime{};
         startTime_= camera_->GetCurrentMMTime();
         lastFrameTime_ = MM::MMTime{};
      }
      bool IsStopped(){
         MMThreadGuard g(this->stopLock_);
         return stop_;
      }
      void Suspend() {
         MMThreadGuard g(this->suspendLock_);
         suspend_ = true;
      }
      bool IsSuspended() {
         MMThreadGuard g(this->suspendLock_);
         return suspend_;
      }
      void Resume() {
         MMThreadGuard g(this->suspendLock_);
         suspend_ = false;
      }
      double GetIntervalMs(){return intervalMs_;}
      void SetLength(long images) {numImages_ = images;}
      //long GetLength() const {return numImages_;}
 
      long GetImageCounter(){return imageCounter_;}
      MM::MMTime GetStartTime(){return startTime_;}
      MM::MMTime GetActualDuration(){return actualDuration_;}
 
      CLegacyCameraBase* GetCamera() {return camera_;}
      long GetNumberOfImages() {return numImages_;}
 
      void UpdateActualDuration() {actualDuration_ = camera_->GetCurrentMMTime() - startTime_;}
 
   private:
      virtual int svc()
      {
         int ret=DEVICE_ERR;
         try
         {
            do
            {
               ret=camera_->ThreadRun();
            } while (DEVICE_OK == ret && !IsStopped() && imageCounter_++ < numImages_-1);
            if (IsStopped())
               camera_->LogMessage("SeqAcquisition interrupted by the user\n");
 
         }catch(...){
            camera_->LogMessage(g_Msg_EXCEPTION_IN_THREAD, false);
         }
         stop_=true;
         UpdateActualDuration();
         camera_->OnThreadExiting();
         return ret;
      }
   private:
      double intervalMs_;
      long numImages_;
      long imageCounter_;
      bool stop_;
      bool suspend_;
      CLegacyCameraBase* camera_;
      MM::MMTime startTime_;
      MM::MMTime actualDuration_;
      MM::MMTime lastFrameTime_;
      MMThreadLock stopLock_;
      MMThreadLock suspendLock_;
   };
 
 
private:
 
   bool busy_;
   bool stopWhenCBOverflows_;
 
   BaseSequenceThread * thd_;
   friend class BaseSequenceThread;
};
 
 
template <class U>
class CStageBase : public CDeviceBase<MM::Stage, U>
{
   virtual int GetPositionUm(double& pos) = 0;
   virtual int SetPositionUm(double pos) = 0;
 
   virtual int SetRelativePositionUm(double d)
   {
      double pos;
      int ret = GetPositionUm(pos);
      if (ret != DEVICE_OK)
         return ret;
      return SetPositionUm(pos + d);
   }
 
   virtual int SetAdapterOriginUm(double /*d*/)
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int Move(double /*velocity*/)
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int Stop()
   {
      // Historically, Move() has been in this interface longer than Stop(), so
      // there is a chance that a stage implements Move() but not Stop(). In
      // which case zero velocity is the best thing to do.
      return Move(0.0);
   }
 
   virtual int Home()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int GetFocusDirection(MM::FocusDirection& direction)
   {
      // FocusDirectionUnknown is a safe default for all stages. Override this
      // only if direction is known for sure (i.e. does not depend on how the
      // hardware is installed).
      direction = MM::FocusDirectionUnknown;
      return DEVICE_OK;
   }
 
   virtual int UsesOnStagePositionChanged(bool& result) const
   {
      result = false;
      return DEVICE_OK;
   }
 
   virtual int IsStageLinearSequenceable(bool& isSequenceable) const
   {
      isSequenceable = false;
      return DEVICE_OK;
   }
 
   virtual int GetStageSequenceMaxLength(long& /*nrEvents*/) const
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int StartStageSequence()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int StopStageSequence()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int ClearStageSequence()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int AddToStageSequence(double /*position*/)
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int SendStageSequence()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int SetStageLinearSequence(double, long)
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
};
 
template <class U>
class CXYStageBase : public CDeviceBase<MM::XYStage, U>
{
public:
   CXYStageBase() : originXSteps_(0), originYSteps_(0), xPos_(0), yPos_(0)
   {
      // set-up directionality properties
      this->CreateProperty(MM::g_Keyword_Transpose_MirrorX, "0", MM::Integer, false);
      this->AddAllowedValue(MM::g_Keyword_Transpose_MirrorX, "0");
      this->AddAllowedValue(MM::g_Keyword_Transpose_MirrorX, "1");
 
      this->CreateProperty(MM::g_Keyword_Transpose_MirrorY, "0", MM::Integer, false);
      this->AddAllowedValue(MM::g_Keyword_Transpose_MirrorY, "0");
      this->AddAllowedValue(MM::g_Keyword_Transpose_MirrorY, "1");
   }
 
   // This converts an absolute position (x_um, y_um), under the current
   // adapter origin and x/y mirroring, to an absolute step position. Do not
   // use for relative offsets.
   std::pair<long, long> ConvertPositionUmToSteps(double x_um, double y_um)
   {
      bool mirrorX, mirrorY;
      GetOrientation(mirrorX, mirrorY);
 
      long xSteps{}, ySteps{};
      if (mirrorX)
         xSteps = originXSteps_ - nint (x_um / this->GetStepSizeXUm());
      else
         xSteps = originXSteps_ + nint (x_um / this->GetStepSizeXUm());
      if (mirrorY)
         ySteps = originYSteps_ - nint (y_um / this->GetStepSizeYUm());
      else
         ySteps = originYSteps_ + nint (y_um / this->GetStepSizeYUm());
 
      return {xSteps, ySteps};
   }
 
   // This converts an absolute position (xSteps, ySteps), under the current
   // adapter origin and x/y mirroring, to an absolute um position. Do not use
   // for relative offsets.
   std::pair<double, double> ConvertPositionStepsToUm(long xSteps, long ySteps)
   {
      bool mirrorX, mirrorY;
      GetOrientation(mirrorX, mirrorY);
 
      double x_um{}, y_um{};
      if (mirrorX)
         x_um = (originXSteps_ - xSteps) * this->GetStepSizeXUm();
      else
         x_um =  - ((originXSteps_ - xSteps) * this->GetStepSizeXUm());
 
      if (mirrorY)
         y_um = (originYSteps_ - ySteps) * this->GetStepSizeYUm();
      else
         y_um = - ((originYSteps_ - ySteps) * this->GetStepSizeYUm());
 
      return {x_um, y_um};
   }
 
   virtual int SetPositionUm(double x_um, double y_um)
   {
      auto posSteps = ConvertPositionUmToSteps(x_um, y_um);
      long xSteps = posSteps.first;
      long ySteps = posSteps.second;
 
      int ret = this->SetPositionSteps(xSteps, ySteps);
      if (ret == DEVICE_OK) {
         xPos_ = x_um;
         yPos_ = y_um;
      }
      return ret;
   }
 
   virtual int SetRelativePositionUm(double dx, double dy)
   {
      bool mirrorX, mirrorY;
      GetOrientation(mirrorX, mirrorY);
      double xPos = xPos_ + dx;
      double yPos = yPos_ + dy;
 
      if (mirrorX)
         dx = -dx;
      if (mirrorY)
         dy = -dy;
 
      int ret = SetRelativePositionSteps(nint(dx / this->GetStepSizeXUm()), nint(dy / this->GetStepSizeYUm()));
      if (ret == DEVICE_OK) {
         xPos_ = xPos;
         yPos_ = yPos;
      }
      return ret;
   }
 
   virtual int SetAdapterOriginUm(double newXUm, double newYUm)
   {
      bool mirrorX, mirrorY;
      GetOrientation(mirrorX, mirrorY);
 
      long xStep, yStep;
      int ret = this->GetPositionSteps(xStep, yStep);
      if (ret != DEVICE_OK)
         return ret;
 
      if (mirrorX)
         originXSteps_ = xStep + nint(newXUm / this->GetStepSizeXUm());
      else
         originXSteps_ = xStep - nint(newXUm / this->GetStepSizeXUm());
      if (mirrorY)
         originYSteps_ = yStep + nint(newYUm / this->GetStepSizeYUm());
      else
         originYSteps_ = yStep - nint(newYUm / this->GetStepSizeYUm());
 
      return DEVICE_OK;
   }
 
   virtual int GetPositionUm(double& x_um, double& y_um)
   {
      long xSteps, ySteps;
      int ret = this->GetPositionSteps(xSteps, ySteps);
      if (ret != DEVICE_OK)
         return ret;
 
      auto pos_um = ConvertPositionStepsToUm(xSteps, ySteps);
      x_um = pos_um.first;
      y_um = pos_um.second;
 
      xPos_ = x_um;
      yPos_ = y_um;
 
      return DEVICE_OK;
   }
 
   virtual int SetRelativePositionSteps(long x, long y)
   {
      long xSteps, ySteps;
      int ret = this->GetPositionSteps(xSteps, ySteps);
      if (ret != DEVICE_OK)
         return ret;
 
      return this->SetPositionSteps(xSteps+x, ySteps+y);
   }
 
   virtual int UsesOnXYStagePositionChanged(bool& result) const
   {
      result = false;
      return DEVICE_OK;
   }
 
   virtual int Move(double /*vx*/, double /*vy*/)
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int SetXOrigin()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int SetYOrigin()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int GetXYStageSequenceMaxLength(long& /*nrEvents*/) const
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int StartXYStageSequence()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int StopXYStageSequence()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int ClearXYStageSequence()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int AddToXYStageSequence(double /*positionX*/, double /*positionY*/)
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int SendXYStageSequence()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
protected:
 
   double GetCachedXUm() {return xPos_;}
   double GetCachedYUm() {return yPos_;}
 
private:
 
   void GetOrientation(bool& mirrorX, bool& mirrorY)
   {
      char val[MM::MaxStrLength];
      int ret = this->GetProperty(MM::g_Keyword_Transpose_MirrorX, val);
      assert(ret == DEVICE_OK);
      mirrorX = strcmp(val, "1") == 0 ? true : false;
 
      ret = this->GetProperty(MM::g_Keyword_Transpose_MirrorY, val);
      assert(ret == DEVICE_OK);
      mirrorY = strcmp(val, "1") == 0 ? true : false;
   }
 
 
   // absolute coordinate translation data
   long originXSteps_;
   long originYSteps_;
   double xPos_;
   double yPos_;
};
 
template <class U>
class CShutterBase : public CDeviceBase<MM::Shutter, U>
{
};
 
template <class U>
class CSerialBase : public CDeviceBase<MM::Serial, U>
{
};
 
template <class U>
class CAutoFocusBase : public CDeviceBase<MM::AutoFocus, U>
{
   virtual int AutoSetParameters() {return DEVICE_UNSUPPORTED_COMMAND;}
};
 
template <class U>
class CImageProcessorBase : public CDeviceBase<MM::ImageProcessor, U>
{
};
 
template <class U>
class CSignalIOBase : public CDeviceBase<MM::SignalIO, U>
{
   virtual int GetDASequenceMaxLength(long& /*nrEvents*/) const
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int StartDASequence()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int StopDASequence() {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int ClearDASequence() {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int AddToDASequence(double /*voltage*/)
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int SendDASequence() {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
};
 
template <class U>
class CMagnifierBase : public CDeviceBase<MM::Magnifier, U>
{
};
 
template <class U>
class CSLMBase : public CDeviceBase<MM::SLM, U>
{
   virtual int GetSLMSequenceMaxLength(long& /*nrEvents*/) const
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int StartSLMSequence()
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int StopSLMSequence() {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int ClearSLMSequence() {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int AddToSLMSequence(const unsigned char * const /*image*/)
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int AddToSLMSequence(const unsigned int * const /*image*/)
   {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
 
   virtual int SendSLMSequence() {
      return DEVICE_UNSUPPORTED_COMMAND;
   }
};
 
template <class U>
class CGalvoBase : public CDeviceBase<MM::Galvo, U>
{
   double GetXMinimum() { return 0.0;};
   double GetYMinimum() { return 0.0;};
};
 
template <class U>
class HubBase : public CDeviceBase<MM::Hub, U>
{
public:
   HubBase() {}
   virtual ~HubBase() {}
 
   virtual int DetectInstalledDevices() {return DEVICE_OK;}
 
   virtual unsigned GetNumberOfInstalledDevices() {return (unsigned)installedDevices.size();}
 
   virtual MM::Device* GetInstalledDevice(int devIdx) {return installedDevices[devIdx];}
 
   virtual void ClearInstalledDevices()
   {
      for (unsigned i=0; i<installedDevices.size(); i++)
         delete installedDevices[i];
      installedDevices.clear();
   }
 
protected:
   void AddInstalledDevice(MM::Device* pdev) {installedDevices.push_back(pdev);}
 
private:
   std::vector<MM::Device*> installedDevices;
 
};
 
template <class U>
class CStateDeviceBase : public CDeviceBase<MM::State, U>
{
public:
 
   typedef CStateDeviceBase<U> CStateBase;
 
   CStateDeviceBase(): gateOpen_(true)
   {
      // set-up Position to move to when the state device's gate is closed
      // Allowed values should be set in the state device adapter
      // this->CreateProperty(MM::g_Keyword_Closed_Position, "0", MM::String, false);
   }
 
   virtual int SetPosition(long pos)
   {
      return this->SetProperty(MM::g_Keyword_State, CDeviceUtils::ConvertToString(pos));
   }
 
   virtual int SetPosition(const char* label)
   {
      std::map<std::string, long>::const_iterator it;
      it = labels_.find(label);
      if (it == labels_.end())
         return DEVICE_UNKNOWN_LABEL;
 
      return SetPosition(it->second);
   }
 
 
   virtual int SetGateOpen(bool open)
   {
      if (gateOpen_ != open) {
         gateOpen_ = open;
         long position;
         int ret = GetPosition(position);
         if  (ret != DEVICE_OK)
            return ret;
         return SetPosition(position);
      }
      return DEVICE_OK;
   }
 
   virtual int GetGateOpen(bool& open)
   {
      open = gateOpen_;
      return DEVICE_OK;
   }
 
   virtual int GetPosition(long& pos) const
   {
      char buf[MM::MaxStrLength];
      assert(this->HasProperty(MM::g_Keyword_State));
      int ret = this->GetProperty(MM::g_Keyword_State, buf);
      if (ret == DEVICE_OK)
      {
         pos = atol(buf);
         return DEVICE_OK;
      }
      else
         return ret;
   }
 
   virtual int GetPosition(char* label) const
   {
      long pos;
      int ret = GetPosition(pos);
      if (ret == DEVICE_OK)
         return GetPositionLabel(pos, label);
      else
         return ret;
   }
 
   virtual int GetPositionLabel(long pos, char* label) const
   {
      std::map<std::string, long>::const_iterator it;
      for (it=labels_.begin(); it!=labels_.end(); it++)
      {
         //string devLabel = it->first;
         //long devPosition  = it->second;
         if (it->second == pos)
         {
            CDeviceUtils::CopyLimitedString(label, it->first.c_str());
            return DEVICE_OK;
         }
      }
 
      // label not found
      return DEVICE_UNKNOWN_POSITION;
   }
 
   virtual int SetPositionLabel(long pos, const char* label)
   {
      // first test if the label already exists with different position defined
      std::map<std::string, long>::iterator it;
      it = labels_.find(label);
      if (it != labels_.end() && it->second != pos)
      {
         // remove the existing one
         labels_.erase(it);
      }
 
      // then test if the given position already has a label
      for (it=labels_.begin(); it!=labels_.end(); it++)
      {
         if (it->second == pos)
         {
            labels_.erase(it);
            break;
         }
      }
 
      // finally we can add the new label-position mapping
      labels_[label] = pos;
 
      // attempt to define allowed values for label property (if it exists),
      // and don't make any fuss if the operation fails
      std::string strLabel(label);
      std::vector<std::string> values;
      for (it=labels_.begin(); it!=labels_.end(); it++)
         values.push_back(it->first);
      this->SetAllowedValues(MM::g_Keyword_Label, values);
 
      return DEVICE_OK;
   }
 
   virtual int GetLabelPosition(const char* label, long& pos) const
   {
      std::map<std::string, long>::const_iterator it;
      it = labels_.find(label);
      if (it == labels_.end())
         return DEVICE_UNKNOWN_LABEL;
 
      pos = it->second;
      return DEVICE_OK;
   }
 
   int OnLabel(MM::PropertyBase* pProp, MM::ActionType eAct)
   {
      if (eAct == MM::BeforeGet)
      {
         char buf[MM::MaxStrLength];
         int ret = GetPosition(buf);
         if (ret != DEVICE_OK)
            return ret;
         pProp->Set(buf);
      }
      else if (eAct == MM::AfterSet)
      {
         std::string label;
         pProp->Get(label);
         int ret = SetPosition(label.c_str());
         if (ret != DEVICE_OK)
            return ret;
      }
      else if (eAct == MM::IsSequenceable)
      {
         assert(this->HasProperty(MM::g_Keyword_State));
         bool sequenceable;
         int ret = this->IsPropertySequenceable(MM::g_Keyword_State, sequenceable);
         if (ret != DEVICE_OK)
            return ret;
 
         long nrEvents = 0;
         if (sequenceable) {
            ret = this->GetPropertySequenceMaxLength(MM::g_Keyword_State, nrEvents);
            if (ret != DEVICE_OK)
               return ret;
         }
         pProp->SetSequenceable(nrEvents);
      }
      else if (eAct == MM::AfterLoadSequence) {
         assert(this->HasProperty(MM::g_Keyword_State));
         std::vector<std::string> sequence = pProp->GetSequence();
         for (std::vector<std::string>::iterator it = sequence.begin(); it != sequence.end(); ++it) {
            long pos;
            int ret = GetLabelPosition((*it).c_str(), pos);
            if (ret != DEVICE_OK)
               return ret;
            std::stringstream s;
            s << pos;
            s >> *it;
         }
 
         int ret = this->ClearPropertySequence(MM::g_Keyword_State);
         if (ret != DEVICE_OK)
            return ret;
 
         std::vector<std::string>::iterator it;
         for ( it=sequence.begin() ; it < sequence.end(); it++ )
         {
            ret = this->AddToPropertySequence(MM::g_Keyword_State, (*it).c_str());
            if (ret != DEVICE_OK)
               return ret;
         }
 
         ret = this->SendPropertySequence(MM::g_Keyword_State);
         if (ret != DEVICE_OK)
            return ret;
 
         //this->LoadPropertySequence(MM::g_Keyword_State, sequence);
      }
      else if (eAct == MM::StartSequence) {
         assert(this->HasProperty(MM::g_Keyword_State));
         return this->StartPropertySequence(MM::g_Keyword_State);
      }
      else if (eAct == MM::StopSequence) {
         assert(this->HasProperty(MM::g_Keyword_State));
         return this->StopPropertySequence(MM::g_Keyword_State);
      }
 
      return DEVICE_OK;
   }
 
   int OnStateChanged(long position) {
      int ret;
      ret = this->OnPropertyChanged(MM::g_Keyword_State,CDeviceUtils::ConvertToString(position));
      if (ret != DEVICE_OK) {
         return ret;
      }
 
      char label[MM::MaxStrLength];
      GetPositionLabel(position, label);
      ret = this->OnPropertyChanged(MM::g_Keyword_Label, label);
      return ret;
   }
 
private:
   bool gateOpen_;
 
private:
   std::map<std::string, long> labels_;
};
 
template <class U>
class CVolumetricPumpBase : public CDeviceBase<MM::VolumetricPump, U>
{
    int Home()
    {
        return DEVICE_UNSUPPORTED_COMMAND;
    }
 
    int InvertDirection(bool /*state*/)
    {
        return DEVICE_UNSUPPORTED_COMMAND;
    }
};
 
template <class U>
class CPressurePumpBase : public CDeviceBase<MM::PressurePump, U>
{
    int Calibrate()
    {
        return DEVICE_UNSUPPORTED_COMMAND;
    }
};