CDepthBitmap.h

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ImtCore-Commercial
#pragma once
 
 
// ACF includes
#include <iimg/CReflectedBitmapBase.h>
#include <idoc/CStandardDocumentMetaInfo.h>
 
// ImtCore includes
#include <imt3d/IDepthBitmap.h>
#include <imt3d/CImage3dCalibration.h>
 
 
namespace imt3d
{
 
 
class CDepthBitmap:
                     virtual public imt3d::IDepthBitmap,
                     public iimg::CReflectedBitmapBase,
                     public idoc::CStandardDocumentMetaInfo
{
public:
       enum ColorMapType
       {
              CMT_JET,
 
              CMT_GRAY
       };
 
       enum
       {
              MIT_CALIBRATION = MIT_LAST + 1,
              MIT_CALIBRATION_TYPE_ID,
              MIT_CALIBRATION_3D,
              MIT_REFERENCE_BITMAP,
              MIT_ROBOT_TRAJECTORY
       };
 
       typedef iimg::CReflectedBitmapBase BaseClass;
       typedef idoc::CStandardDocumentMetaInfo BaseClass2;
 
       CDepthBitmap();
 
       void SetDepthRange(const istd::CRange& depthRange);
       void SetColorMap(ColorMapType colorMapType);
       void SetCalibration3d(const CImage3dCalibration& calibration3d);
       void SetReferenceBitmap(const iimg::CGeneralBitmap& referenceBitmap);
       void ResetReferenceBitmap();
       void SetRobotTrajectory(const IDepthBitmap::RobotTrajectory& robotPositions);
       void SetBaseCorrection(const IDepthBitmap::BaseCorrection& baseCorrection);
 
       bool ComputeDepthRange(const i2d::IObject2d* aoi, istd::CRange& depthRange) const;
 
       // reimplemented (IDepthBitmap)
       virtual istd::CRange GetDepthRange() const override;
       virtual bool CreateDepthBitmap(const istd::CRange & depthRange, const istd::CIndex2d & size) override;
       virtual const IImage3dCalibration* GetCalibration3d() const override;
       virtual const iimg::IBitmap* GetReferenceBitmap() const override;
       virtual RobotTrajectory GetRobotTrajectory() const override;
       virtual BaseCorrection GetBaseCorrection() const override;
       istd::CIndex2d GetSize() const { return GetImageSize(); }
 
       // reimplemented (iimg::IRasterImage)
       virtual void ResetImage() override;
       virtual void ClearImage() override;
 
       // reimplemented (i2d::CObject2dBase)
       virtual void SetCalibration(const i2d::ICalibration2d* calibrationPtr, bool releaseFlag) override;
 
       // reimplemented (iser::ISerializable)
       virtual bool Serialize(iser::IArchive& archive) override;
 
       // reimplemented (istd::IChangeable)
       virtual int GetSupportedOperations() const override;
       virtual bool CopyFrom(const IChangeable& object, CompatibilityMode mode = CM_WITHOUT_REFS) override;
       virtual bool IsEqual(const IChangeable& object) const override;
       virtual istd::IChangeableUniquePtr CloneMe(CompatibilityMode mode = CM_WITHOUT_REFS) const override;
       virtual bool ResetData(CompatibilityMode mode = CM_WITHOUT_REFS) override;
 
protected:
       // reimplemented (iimg::CReflectedBitmapBase)
       virtual bool ConvertFromQImage(const QImage& image) override;
       virtual bool ConvertToQImage(QImage& result) const override;
 
private:
       static QByteArray SerializeRobotTrajectory(const RobotTrajectory& robotTrajectory);
       static RobotTrajectory DeserealizeRobotTrajectory(const QByteArray& robotTrajectoryArchive);
       void EnsureMetaInfoCreated();
 
private:
       istd::CRange m_depthRange;
       ColorMapType m_colorMapType;
       CImage3dCalibration m_calibration3d;
       iimg::CGeneralBitmap m_referenceBitmap;
       RobotTrajectory m_robotTrajectory;
       BaseCorrection m_baseCorrection;
};
 
 
} // namespace imt3d