IRImager.h

Go to the documentation of this file.

// Copyright (c) 2008-2026 Optris GmbH & Co. KG

 
#pragma once
 
#include <memory>
#include <vector>
 
#include "otcsdk/Exceptions.h"
#include "otcsdk/ProcessInterface.h"
#include "otcsdk/IRImagerClient.h"
#include "otcsdk/IRImagerConfig.h"
#include "otcsdk/alarms/AlarmChannel.h"
#include "otcsdk/common/DeviceType.h"
#include "otcsdk/common/DeviceInfo.h"
#include "otcsdk/common/OperationMode.h"
#include "otcsdk/common/RadiationParameters.h"
#include "otcsdk/common/TemperaturePrecision.h"
#include "otcsdk/common/RdcMode.h"
#include "otcsdk/communication/net/DeviceNetworkConfig.h"
#include "otcsdk/fields/MeasurementField.h"
 
 
namespace optris
{

class IRImager
{
public:
  IRImager() = default;

  IRImager(const IRImager&) = delete;
  IRImager& operator=(const IRImager&) = delete;

  IRImager(IRImager&&) = delete;
  IRImager& operator=(IRImager&&) = delete;

  virtual ~IRImager() = default;
 
 
  // Device connection
  virtual void connect(IRImagerConfig config) = 0;

  virtual void connect(const DeviceInfo& deviceInfo) = 0;

  virtual void connect(unsigned long serialNumber) = 0;
  
  virtual void disconnect() noexcept = 0;

  virtual bool isConnected() const noexcept = 0;
 
 
  // Client/Observer management
  virtual bool addClient(IRImagerClient* client) noexcept = 0;

  virtual bool removeClient(IRImagerClient* client) noexcept = 0;
 
 
  // Processing controls
  virtual bool run() = 0;

  virtual bool runAsync() = 0;

  virtual void stopRunning() = 0;

  virtual bool isRunning() const noexcept = 0;

  virtual bool skipStartupCalibration() noexcept = 0;

  virtual void setProcessingOutputs(const ProcessingOutputConfig& outputs) = 0;

  virtual ProcessingOutputConfig getProcessingOutputs() const noexcept = 0;

  virtual void setProcessingMaxResultPoolSize(unsigned int maxPoolSize) = 0;

  virtual unsigned int getProcessingMaxResultPoolSize() const noexcept = 0;
 
 
  // Device information
  virtual DeviceType getDeviceType() const = 0;

  virtual unsigned long getSerialNumber() const = 0;

  virtual unsigned int getHardwareRevision() const = 0;

  virtual unsigned int getFirmwareRevision() const = 0;
 
 
  // Configuration
  virtual IRImagerConfig getConfig() = 0;

  virtual void saveConfig() = 0;
 
  
  // Connection details
  virtual std::string getConnectionInterface() const noexcept = 0;

  virtual IpAddress getIpAddress() const noexcept = 0;

  virtual Port getPort() const noexcept = 0;
 
 
  // Operation modes
  virtual std::vector<OperationMode::ConstShared> getOperationModes() = 0;

  virtual void setActiveOperationMode(const OperationMode::ConstShared& mode) = 0;

  virtual void setActiveOperationMode(int                opticsFieldOfView, 
                                      const std::string& opticsText, 
                                      float              temperatureLowerLimit,
                                      float              temperatureUpperLimit, 
                                      int                width,
                                      int                height,
                                      int                framerate) = 0;

  virtual OperationMode::ConstShared getActiveOperationMode() = 0;
 
 
  // Optics options
  virtual void setSoSCorrectionEnabled(bool enable) = 0;

  virtual bool isSoSCorrectionEnabled() const noexcept = 0;

  virtual void setRdcMode(RdcMode rdcMode) = 0;

  virtual RdcMode getRdcMode() const = 0;
  
  
  // Temperature range options
  virtual void setTemperatureRangeExtensionEnabled(bool enabled) = 0;
  
  virtual bool isTemperatureRangeExtensionEnabled() const noexcept = 0;

  virtual void setTemperatureHighPrecisionEnabled(bool enabled) = 0;

  virtual bool isTemperatureHighPrecisionEnabled() const noexcept = 0;
 
 
  // Video format
  virtual int getWidth() const noexcept = 0;

  virtual int getHeight() const noexcept = 0;

  virtual float getSubsampledFramerate() const noexcept = 0;

  virtual void setSubsampledFramerate(float subsampledFramerate) = 0;
 
 
  // Measurement fields
  virtual MeasurementField::ConstShared addMeasurementField(const MeasurementFieldConfig& config) = 0;

  virtual void removeMeasurementField(const MeasurementField::ConstShared& field) = 0;

  virtual std::vector<MeasurementField::ConstShared> getMeasurementFields() const noexcept = 0;

  virtual int getMeasurementFieldCount() const noexcept = 0;

  virtual void updateMeasurementField(const MeasurementField::ConstShared& field, const MeasurementFieldConfig& config) = 0;

  virtual void swapMeasurementFieldIndices(std::uint32_t index1, std::uint32_t index2) = 0;
 
 
  // Alarms
  virtual AlarmChannel::ConstShared addAlarmChannel(const AlarmChannelConfig& config) = 0;

  virtual void removeAlarmChannel(const AlarmChannel::ConstShared& channel) = 0;

  virtual std::vector<AlarmChannel::ConstShared> getAlarmChannels() const noexcept = 0;

  virtual std::vector<AlarmChannelStatus> getAlarmChannelStatuses() const noexcept = 0;

  virtual int getAlarmChannelCount() const noexcept = 0;

  virtual void updateAlarmChannel(const AlarmChannel::ConstShared& channel, const AlarmChannelConfig& config) = 0;
 
 
  // Shutter flag
  virtual void setAutoFlagEnabled(bool enable) = 0;

  virtual bool isAutoFlagEnabled() const noexcept = 0;

  virtual void setFlagInterval(float minInterval, float maxInterval) = 0;

  virtual float getFlagMinInterval() const noexcept = 0;

  virtual float getFlagMaxInterval() const noexcept = 0;

  virtual void forceFlagEvent(float time = 0.F) = 0;

  virtual bool isFlagOpen() const noexcept = 0;

  virtual void setFlagForecastEnabled(bool enable) = 0;

  virtual bool isFlagForecastEnabled() const noexcept = 0;
 
 
  // Internal temperature probes
  virtual float getTemperatureFlag() const noexcept = 0;

  virtual float getTemperatureBox() const noexcept = 0;

  virtual float getTemperatureChip() const noexcept = 0;
 
 
  // Sensor chip heating
  virtual void setChipHeatingMode(ChipHeatingMode mode, float temperature = 40.F) = 0;

  virtual ChipHeatingMode getChipHeatingMode() const noexcept = 0;

  virtual float getChipHeatingTemperature() const noexcept = 0;
 
 
  // Radiation parameters
  virtual RadiationParameterSource getEmissivitySource() const noexcept = 0;

  virtual RadiationParameterSource getTransmissivitySource() const noexcept = 0;

  virtual RadiationParameterSource getAmbientTemperatureSource() const noexcept = 0;

  virtual void setRadiationParameters(const RadiationParameters& radiation) = 0;

  virtual RadiationParameters getRadiationParameters() const noexcept = 0;
 
  
  // Focus motor
  virtual void setFocusMotorPosition(float position) = 0;

  virtual float getFocusMotorPosition() const = 0;
 
 
  // Reference temperature
  virtual void setReferenceTemperature(float referenceTemperature, float measuredTemperature, float ambientTemperature = INVALID_TEMPERATURE) = 0;

  virtual void resetReferenceTemperature() = 0;
 
 
  // Device network configuration
  virtual bool setDeviceNetworkConfig(const DeviceNetworkConfig& networkConfig) = 0;

  virtual DeviceNetworkConfig getDeviceNetworkConfig() = 0;
 
 
  // Process Interface
  virtual ProcessInterface& getPif() = 0;

  virtual const ProcessInterface& getPif() const = 0;
 
 
  // Fail safe
  virtual void interruptFailSafe(bool active, const std::string& reason) = 0;
  
 
  // Debugging
  virtual void configureOperationInfo(int interval, int x, int y) = 0;
};
 
} // namespace optris