MeasurementField.h

Go to the documentation of this file.

// Copyright (c) 2025 Optris GmbH Co. KG

 
#pragma once
 
#include <vector>
#include <cstdlib>
 
#include "otcsdk/Api.h"
#include "otcsdk/Exceptions.h"
#include "otcsdk/common/MeasurementFieldIterator.h"
#include "otcsdk/common/TemperatureConverter.h"
 
 
namespace optris
{

class MeasurementField
{
  // Special iterator access.
  friend class ConstMeasurementFieldIterator;
  
 
public:
  OTC_SDK_API MeasurementField() noexcept;

  OTC_SDK_API MeasurementField(int   id, 
                               int   x, 
                               int   y, 
                               int   width, 
                               int   height, 
                               float emissivity         = 1.F, 
                               float transmissivity     = 1.F,
                               float ambientTemperature = INVALID_TEMPERATURE) noexcept;

  OTC_SDK_API MeasurementField(const MeasurementField& rhs) = default;
  OTC_SDK_API MeasurementField& operator=(const MeasurementField& rhs) = default;

  OTC_SDK_API MeasurementField(MeasurementField&& rhs) noexcept = default;
  OTC_SDK_API MeasurementField& operator=(MeasurementField&& rhs) noexcept = default;

  OTC_SDK_API ~MeasurementField() = default;
 

  int getId() const noexcept;

  void setId(int id) noexcept;
 

  OTC_SDK_API unsigned short getValue(int index) const;

  float getTemperature(int index) const;

  OTC_SDK_API unsigned short getValue(int x, int y) const;

  float getTemperature(int x, int y) const noexcept(false);
 

  ConstMeasurementFieldIterator getConstIterator() const noexcept;

  TemperaturePrecision getTemperaturePrecision() const noexcept;

  int getX() const noexcept;

  int getY() const noexcept;
 

  void setPosition(int x, int y) noexcept;
 

  int getWidth() const noexcept;

  int getHeight() const noexcept;

  int getSize() const noexcept;

  OTC_SDK_API void resize(int width, int height);
 

  float getEmissivity() const noexcept;

  float getTransmissivity() const noexcept;

  float getAmbientTemperature() const noexcept;
 

  OTC_SDK_API void setRadiationParameters(float emissivity, float transmissivity, float ambientTemperature);
 

  float getMeanTemperature() const noexcept;

  float getMinTemperature() const noexcept;

  float getMaxTemperature() const noexcept;

  void setTemperatures(float mean, float min, float max) noexcept;
 

  TemperatureConverter getConverter() const noexcept;
  

  MeasurementField clone() const noexcept;

  OTC_SDK_API void setData(const unsigned short* source, int frameWidth, TemperaturePrecision precision);

  OTC_SDK_API void setFromRawData(const void* source, TemperaturePrecision precision);

  OTC_SDK_API void copyDataTo(unsigned short* destination, int size) const noexcept;

  const unsigned short* getData() const noexcept;
  
 
private:
  int _id;

  int _x;
  int _y;

  int _width;
  int _height;

  float _emissivity;
  float _transmissivity;
  float _ambientTemperature;

  std::vector<unsigned short> _values;

  float _meanTemperature;
  float _minTemperature;
  float _maxTemperature;

  TemperatureConverter _converter;
};
 
 
// Inline implementations
inline int MeasurementField::getId() const noexcept
{
  return _id;
}
 
inline void MeasurementField::setId(int id) noexcept
{
  _id = id;
}
 
inline float MeasurementField::getTemperature(int index) const noexcept(false)
{
  return _converter.toTemperature(getValue(index));
}
 
inline float MeasurementField::getTemperature(int x, int y) const noexcept(false)
{
  return _converter.toTemperature(getValue(x, y));
}
 
inline ConstMeasurementFieldIterator MeasurementField::getConstIterator() const noexcept
{
  return ConstMeasurementFieldIterator{*this};
}
 
inline TemperaturePrecision MeasurementField::getTemperaturePrecision() const noexcept
{
  return _converter.getPrecision();
}
 
inline int MeasurementField::getX() const noexcept
{
  return _x;
}
 
inline int MeasurementField::getY() const noexcept
{
  return _y;
}
 
inline void MeasurementField::setPosition(int x, int y) noexcept
{
  _x = x;
  _y = y;
}
 
inline int MeasurementField::getWidth() const noexcept
{
  return _width;
}
 
inline int MeasurementField::getHeight() const noexcept
{
  return _height;
}
 
inline int MeasurementField::getSize() const noexcept
{
  return static_cast<int>(_values.size());
}
 
inline float MeasurementField::getEmissivity() const noexcept
{
  return _emissivity;
}
 
inline float MeasurementField::getTransmissivity() const noexcept
{
  return _transmissivity;
}
 
inline float MeasurementField::getAmbientTemperature() const noexcept
{
  return _ambientTemperature;
}
 
inline float MeasurementField::getMeanTemperature() const noexcept
{
  return _meanTemperature;
}
 
inline float MeasurementField::getMinTemperature() const noexcept
{
  return _minTemperature;
}
 
inline float MeasurementField::getMaxTemperature() const noexcept
{
  return _maxTemperature;
}
 
inline void MeasurementField::setTemperatures(float mean, float min, float max) noexcept
{
  _meanTemperature = mean;
  _minTemperature  = min;
  _maxTemperature  = max;
}
 
inline TemperatureConverter MeasurementField::getConverter() const noexcept
{
  return _converter;
}
 
inline MeasurementField MeasurementField::clone() const noexcept
{
  return MeasurementField{*this};
}
 
inline const unsigned short* MeasurementField::getData() const noexcept
{
  return _values.data();
}
 
} // namespace optris