NeoCamera.h

Go to the documentation of this file.

/*
Copyright 2007-2026. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
#pragma once
#include <agxOSG/SceneDecorator.h>
#include <agxOSG/export.h>
 
#include <agxSDK/Simulation.h>
 
#include <agx/Referenced.h>
#include <agx/Vec2.h>
 
#include <osg/Camera>
#include <osg/Texture2D>
#include <osg/View>
 
#include <array>
#include <optional>
#include <unordered_map>
 
namespace agxOSG
{
  using OptionalExposureCompensation = std::optional<agx::Real>;
  using OptionalDynamicRange = std::optional<agx::Real>;
  using OptionalFocusDistance = std::optional<agx::Real>;
  using OptionalFocusMinimumDistance = std::optional<agx::Real>;
  using DistortionModelParameters = std::array<agx::Real, 5>;
  using OptionalFramerate = std::optional<agx::Real>;
 
  AGX_DECLARE_POINTER_TYPES(NeoCamera);
  AGX_DECLARE_POINTER_TYPES(NeoCameraLens);
  AGX_DECLARE_POINTER_TYPES(NeoCameraSensor);
  AGX_DECLARE_POINTER_TYPES(NeoCameraOutput);
  AGX_DECLARE_VECTOR_TYPES(NeoCameraOutput);
  AGX_DECLARE_POINTER_TYPES(NeoCameraColorTextureOutput);
  AGX_DECLARE_POINTER_TYPES(NeoCameraColorImageOutput);
 
  class AGXOSG_EXPORT NeoCamera : public agx::Referenced
  {
    public:
      static bool isSupported();
 
      static void addPreviewTo(
        agxOSG::SceneDecorator* sceneDecorator, NeoCameraColorTextureOutput* output, const agx::Vec2& position,
        const agx::Vec2& size);
 
      static void removePreviewFrom(agxOSG::SceneDecorator* sceneDecorator, NeoCameraColorTextureOutput* output);
 
    public:
      NeoCamera();
 
      NeoCameraLens* getLens() const;
 
      NeoCameraSensor* getSensor() const;
 
      bool add(NeoCameraOutput* output);
 
      bool remove(NeoCameraOutput* output);
 
      void registerToSceneGraph(osg::Group* sceneGraph, osg::Node* sceneNode);
 
      void setViewMatrix(const osg::Matrixd& viewMatrix);
 
      void setReferenceIlluminance(agx::Real illuminance);
 
      agx::Real getReferenceIlluminance() const;
 
      void setConnectedSimulation(agxSDK::Simulation* simulation);
 
      agxSDK::Simulation* getConnectedSimulation() const;
 
    public:
      friend class NeoCameraLens;
      friend class NeoCameraSensor;
      friend class NeoCameraOutput;
      friend class NeoCameraColorTextureOutput;
      friend class NeoCameraColorImageOutput;
 
      class Pipeline;
 
      ~NeoCamera();
 
    private:
      static std::unordered_map<NeoCameraOutput*, osg::Geometry*>& previews();
 
    private:
      bool m_parametersUpdated;
      NeoCameraLensRef m_lens;
      NeoCameraSensorRef m_sensor;
      NeoCameraOutputRefVector m_outputs;
      agx::Real m_referenceIlluminance;
      agxSDK::SimulationObserver m_simulation;
 
    private:
      std::unique_ptr<Pipeline> m_pipeline;
      osg::Matrixd m_viewMatrix;
  };
 
  class AGXOSG_EXPORT NeoCameraLens : public agx::Referenced
  {
    public:
      enum DistortionModel : std::uint8_t
      {
        DISTORTION_NONE,
        DISTORTION_BROWN_CONRADY
      };
 
    public:
      NeoCameraLens(NeoCamera* camera);
 
      void setFocalLength(agx::Real focalLength);
 
      agx::Real getFocalLength() const;
 
      void setFStop(agx::Real fStop);
 
      agx::Real getFStop() const;
 
      void setAutofocus(agx::Real minimumFocusDistance);
 
      void setFocusDistance(agx::Real focusDistance);
 
      bool isAutofocusEnabled() const;
 
      OptionalFocusDistance getFocusDistance() const;
 
      OptionalFocusMinimumDistance getMinimumFocusDistance() const;
 
      void setDistortionModelNone();
 
      void setDistortionModelBrownConrady(agx::Real k1, agx::Real k2, agx::Real k3, agx::Real p1, agx::Real p2);
 
      DistortionModel getDistortionModel() const;
 
      const DistortionModelParameters& getDistortionModelParameters() const;
 
    private:
      NeoCameraObserver m_camera;
 
      agx::Real m_focalLength;
      agx::Real m_fStop;
 
      union
      {
          agx::Real distance;
          agx::Real miniumDistance;
      } m_focus;
      bool m_autofocus;
 
      DistortionModelParameters m_distortionModelParameters;
      DistortionModel m_distortionModel;
  };
 
  class AGXOSG_EXPORT NeoCameraSensor : public agx::Referenced
  {
    public:
      NeoCameraSensor(NeoCamera* camera);
 
      void setSize(const agx::Vec2& size);
 
      agx::Vec2 getSize() const;
 
      void setResolution(const agx::Vec2i& resolution);
 
      agx::Vec2i getResolution() const;
 
      void setISO(agx::Real iso);
 
      agx::Real getISO() const;
 
      void setShutterSpeed(agx::Real shutterSpeed);
 
      agx::Real getShutterSpeed() const;
 
      void setCircleOfConfusion(agx::Real circleOfConfusion);
 
      agx::Real getCircleOfConfusion() const;
 
      void setManualExposureCompensation(agx::Real exposureCompensation);
 
      void setAutoExposure(agx::Real dynamicRange);
 
      bool hasAutoExposureEnabled() const;
 
      OptionalExposureCompensation getExposureCompensation() const;
 
      OptionalDynamicRange getDynamicRange() const;
 
    private:
      NeoCameraObserver m_camera;
 
      agx::Vec2 m_size;
      agx::Vec2i m_resolution;
      agx::Real m_iso;
      agx::Real m_shutterSpeed;
      agx::Real m_circleOfConfusion;
 
      union
      {
          agx::Real compensation;
          agx::Real dynamicRange;
      } m_exposure;
      bool m_autoExposure;
  };
 
  class AGXOSG_EXPORT NeoCameraOutput : public agx::Referenced
  {
    public:
      NeoCameraOutput();
 
      NeoCamera* getCamera() const;
 
      void setManualCapture();
 
      void setConstantCapture(agx::Real framerate);
 
      bool isConstantlyCapturing() const;
 
      OptionalFramerate getFramerate() const;
 
      void capture();
 
      bool hasUnreadData(bool markAsRead = true);
 
    public:
      friend class NeoCamera;
 
    private:
      void setLinkedCamera(NeoCamera* camera);
 
    private:
      NeoCameraObserver m_camera;
 
      union
      {
          bool captureNext;
          agx::Real framerate;
      } m_capture;
      bool m_constantCapture;
  };
 
  class AGXOSG_EXPORT NeoCameraColorTextureOutput : public NeoCameraOutput
  {
    public:
      NeoCameraColorTextureOutput();
 
      void setTextureSize(const agx::Vec2i& size);
 
      agx::Vec2i getTextureSize() const;
 
      void setGamma(agx::Real gamma);
 
      agx::Real getGamma() const;
 
      osg::Texture* getTexture() const;
 
    private:
      osg::ref_ptr<osg::Texture2D> m_texture;
      agx::Real m_gamma;
  };
 
  class AGXOSG_EXPORT NeoCameraColorImageOutput : public NeoCameraOutput
  {
    public:
      enum ChannelElementType : uint8_t
      {
        EMPTY,
        I8,
        U8,
        I16,
        U16,
        I32,
        U32,
        F32,
        I64,
        U64,
        F64
      };
 
    public:
      static size_t sizeOf(ChannelElementType type);
 
    public:
      NeoCameraColorImageOutput();
 
      void setImageSize(const agx::Vec2i& size);
 
      const agx::Vec2i& getImageSize() const;
 
      void setGamma(agx::Real gamma);
 
      agx::Real getGamma() const;
 
      void setColorMappingMatrix(const osg::Matrixd& colorMapping);
 
      const osg::Matrixd& getColorMappingMatrix() const;
 
      void setOutputChannelType(ChannelElementType type);
 
      ChannelElementType getOutputChannelType() const;
 
      void setOutputChannels(agx::UInt8 channels);
 
      agx::UInt8 getOutputChannels() const;
 
      size_t getElementSize() const;
 
      void setExternalData(void* externalAddress = nullptr);
 
      size_t getDataSize() const;
 
      const void* getData() const;
 
      template <typename T>
      const T* viewData() const;
 
    private:
      void ensureDataSize();
 
    private:
      agx::Vector<agx::UInt8> m_buffer;
      void* m_externalData;
      agx::Vec2i m_size;
      agx::Real m_gamma;
      osg::Matrixd m_colorMapping;
      ChannelElementType m_type;
      agx::UInt8 m_channels;
  };
 
  template <typename T>
  const T* NeoCameraColorImageOutput::viewData() const
  {
    if (sizeof(T) == getElementSize())
      return reinterpret_cast<const T*>(getData());
    else
      return nullptr;
  }
}