File ManagedImage.h

File List > SpinnakerNET > ManagedImage.h

Go to the documentation of this file

//=============================================================================
// Copyright (c) 2026 FLIR Integrated Imaging Solutions, Inc. All Rights Reserved.
//
// This software is the confidential and proprietary information of FLIR
// Integrated Imaging Solutions, Inc. ("Confidential Information"). You
// shall not disclose such Confidential Information and shall use it only in
// accordance with the terms of the license agreement you entered into
// with FLIR Integrated Imaging Solutions, Inc. (FLIR).
//
// FLIR MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
// SOFTWARE, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE, OR NON-INFRINGEMENT. FLIR SHALL NOT BE LIABLE FOR ANY DAMAGES
// SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
// THIS SOFTWARE OR ITS DERIVATIVES.
//=============================================================================

#ifndef FLIR_SPINNAKER_MANAGED_IMAGE_H
#define FLIR_SPINNAKER_MANAGED_IMAGE_H

#include "ImagePtr.h"
#include "IManagedImage.h"
#include "ManagedChunkData.h"
#include "ManagedDefs.h"
#include "Translate.h"

using namespace ::System;
using namespace ::System::Runtime::InteropServices;

namespace SpinnakerNET
{


    public ref class ManagedImage : IManagedImage
    {
    public:
        ManagedImage();

        ManagedImage(IManagedImage^ srcImage);

        ManagedImage(System::String ^ fileName);

        ManagedImage(unsigned int width, unsigned int height, unsigned int offsetX, unsigned int offsetY, SpinnakerNET::PixelFormatEnums pixelFormat, void* pData);

        ManagedImage(unsigned int width, unsigned int height, unsigned int offsetX, unsigned int offsetY, SpinnakerNET::PixelFormatEnums pixelFormat, void* pData, SpinnakerNET::TLPayloadType dataPayloadType, size_t dataSize);

        virtual ~ManagedImage();
        !ManagedImage();  // Finalizer

        ManagedImage^ operator=(const ManagedImage% other);

        /*
        * Releases an image that was acquired by calling ManagedCameraBase::GetNextImage().
        *
        * @see ManagedCameraBase::GetNextImage()
        *
        */
        virtual void Release();

        virtual property bool HasChunkData
        {
            bool get()
            {
                return (*m_pNativeImagePtr)->HasChunkData();
            }
        }

        virtual property ManagedChunkData^ ChunkData
        {
            ManagedChunkData^ get()
            {
                const Spinnaker::ChunkData* tmp = &(*m_pNativeImagePtr)->GetChunkData();
                return gcnew ManagedChunkData(tmp);
            }
        }

        virtual property unsigned char* NativeData
        {
            unsigned char* get()
            {
                return static_cast<unsigned char*>((*m_pNativeImagePtr)->GetData());
            }
        }

        virtual property unsigned char* PrivateData
        {
            unsigned char* get()
            {
                return static_cast<unsigned char*>((*m_pNativeImagePtr)->GetPrivateData());
            }
        }

        virtual property IntPtr DataPtr
        {
            IntPtr get()
            {
                return IntPtr((*m_pNativeImagePtr)->GetData());
            }
        }

        virtual property array<byte>^ ManagedData
        {
            array<byte>^ get()
            {
                // RAII
                if (m_data == nullptr)
                {
                    m_data = gcnew array<Byte>(ImageSize);

                    // Copy native data to managed space
                    Marshal::Copy(DataPtr, m_data, 0, ImageSize);
                }

                return m_data;
            }
        }

        virtual property System::UInt64 ID
        {
            System::UInt64 get()
            {
                return (*m_pNativeImagePtr)->GetID();
            }
        }

        virtual property System::UInt64 StreamIndex
        {
            System::UInt64 get()
            {
                return (*m_pNativeImagePtr)->GetStreamIndex();
            }
        }

        virtual property System::String ^ SerialNumber
        {
            System::String ^ get()
            {
                return gcnew System::String((*m_pNativeImagePtr)->GetSerialNumber().c_str());
            }
        }

        virtual property unsigned int Width
        {
            unsigned int get()
            {
                return (unsigned int)(*m_pNativeImagePtr)->GetWidth();
            }
        }

        virtual property unsigned int Height
        {
            unsigned int get()
            {
                return (unsigned int)(*m_pNativeImagePtr)->GetHeight();
            }
        }

        virtual property unsigned int Stride
        {
            unsigned int get()
            {
                return (unsigned int)(*m_pNativeImagePtr)->GetStride();
            }
        }

        virtual property unsigned int BitsPerPixel
        {
            unsigned int get()
            {
                return (unsigned int)(*m_pNativeImagePtr)->GetBitsPerPixel();
            }
        }

        virtual property unsigned int NumChannels
        {
            unsigned int get()
            {
                return (unsigned int)(*m_pNativeImagePtr)->GetNumChannels();
            }
        }

        virtual property unsigned int OffsetX
        {
            unsigned int get()
            {
                return (unsigned int)(*m_pNativeImagePtr)->GetXOffset();
            }
        }

        virtual property unsigned int OffsetY
        {
            unsigned int get()
            {
                return (unsigned int)(*m_pNativeImagePtr)->GetYOffset();
            }
        }

        virtual property unsigned int XPadding
        {
            unsigned int get()
            {
                return (unsigned int)(*m_pNativeImagePtr)->GetXPadding();
            }
        }

        virtual property unsigned int YPadding
        {
            unsigned int get()
            {
                return (unsigned int)(*m_pNativeImagePtr)->GetYPadding();
            }
        }

        virtual property System::UInt64 FrameID
        {
            System::UInt64 get()
            {
                return (*m_pNativeImagePtr)->GetFrameID();
            }
        }

        virtual property SpinnakerNET::ImagePayloadType ImagePayloadType
        {
            SpinnakerNET::ImagePayloadType get()
            {
                return (SpinnakerNET::ImagePayloadType)(*m_pNativeImagePtr)->GetImagePayloadType();
            }
        }

        virtual property unsigned int PayloadType
        {
            unsigned int get()
            {
                return (unsigned int)(*m_pNativeImagePtr)->GetPayloadType();
            }
        }

        virtual property unsigned int TLPayloadType
        {
            unsigned int get()
            {
                return (unsigned int)(*m_pNativeImagePtr)->GetTLPayloadType();
            }
        }

        virtual property unsigned int ValidPayloadSize
        {
            unsigned int get()
            {
                return (unsigned int)(*m_pNativeImagePtr)->GetValidPayloadSize();
            }

        }

        virtual property System::UInt64 ChunkLayoutID
        {
            System::UInt64 get()
            {
                return (*m_pNativeImagePtr)->GetChunkLayoutId();
            }

        }

        virtual property System::UInt64 TimeStamp
        {
            System::UInt64 get()
            {
                return (*m_pNativeImagePtr)->GetTimeStamp();
            }
        }

        virtual property System::UInt64 TLPixelFormat
        {
            System::UInt64 get()
            {
                return (*m_pNativeImagePtr)->GetTLPixelFormat();
            }
        }

        virtual property System::Drawing::Bitmap^ bitmap
        {
            System::Drawing::Bitmap^ get()
            {
                UpdateBitmap();
                return m_bitmap;
            }
        }

        virtual property System::Windows::Media::Imaging::BitmapSource^ bitmapsource
        {
            System::Windows::Media::Imaging::BitmapSource^ get()
            {
                return m_bitmapsource;
            }
        }

        virtual property System::Windows::Media::Imaging::WriteableBitmap^ writeableBitmap
        {
            System::Windows::Media::Imaging::WriteableBitmap^ get()
            {
                return m_writeablebitmap;
            }
        }

        virtual property System::String^ PixelFormatName
        {
            System::String^ get()
            {
                return gcnew System::String((*m_pNativeImagePtr)->GetPixelFormatName().c_str());
            }
        }

        virtual property SpinnakerNET::PixelFormatEnums PixelFormat
        {
            SpinnakerNET::PixelFormatEnums get()
            {
                return (SpinnakerNET::PixelFormatEnums)((int)(*m_pNativeImagePtr)->GetPixelFormat());
            }
        }

        virtual property bool IsIncomplete
        {
            bool get()
            {
                return (*m_pNativeImagePtr)->IsIncomplete();
            }
        }

        virtual property unsigned int BufferSize
        {
            unsigned int get()
            {
                return (unsigned int)(*m_pNativeImagePtr)->GetBufferSize();
            }
        }

        virtual SpinnakerNET::ColorProcessingAlgorithm GetColorProcessing();

        virtual unsigned int GetBufferSize();

        virtual void DeepCopy(IManagedImage^ srcImage);

        virtual void Save(
            System::String^ fileName);

        virtual void Save(
            System::String^ fileName,
            ImageFileFormat format);

        virtual void Save(
            System::String^ fileName,
            PngOption^ option);

        virtual void Save(
            System::String^ fileName,
            PpmOption^ option);

        virtual void Save(
            System::String^ fileName,
            PgmOption^ option);

        virtual void Save(
            System::String^ fileName,
            TiffOption^ option);

        virtual void Save(
            System::String^ fileName,
            JpegOption^ option);

        virtual void Save(
            System::String^ fileName,
            Jpg2Option^ option);

        virtual void Save(
            System::String^ fileName,
            BmpOption^ option);

        virtual void ResetImage(unsigned int width, unsigned int height, unsigned int offsetX, unsigned int offsetY, SpinnakerNET::PixelFormatEnums pixelFormat);

        virtual void ResetImage(unsigned int width, unsigned int height, unsigned int offsetX, unsigned int offsetY, SpinnakerNET::PixelFormatEnums pixelFormat, void* pData);

        virtual void ConvertToBitmapSource(SpinnakerNET::PixelFormatEnums format, IManagedImage^ destImage);

        virtual void ConvertToWriteAbleBitmap(SpinnakerNET::PixelFormatEnums format, IManagedImage^ destImage);

        virtual void ConvertToBitmapSource(SpinnakerNET::PixelFormatEnums format, IManagedImage^ destImage, SpinnakerNET::ColorProcessingAlgorithm algorithm);

        virtual void ConvertToWriteAbleBitmap(SpinnakerNET::PixelFormatEnums format, IManagedImage^ destImage, SpinnakerNET::ColorProcessingAlgorithm algorithm);

        virtual void CalculateStatistics(ManagedImageStatistics^ statistics);

        virtual property SpinnakerNET::ImageStatus ImageStatus
        {
            SpinnakerNET::ImageStatus get()
            {
                return (SpinnakerNET::ImageStatus)(*m_pNativeImagePtr)->GetImageStatus();
            }
        }

        virtual property bool HasCRC
        {
            bool get()
            {
                return (*m_pNativeImagePtr)->HasCRC();
            }
        }

        virtual property bool CheckCRC
        {
            bool get()
            {
                return (*m_pNativeImagePtr)->CheckCRC();
            }
        }

        virtual property bool IsInUse
        {
            bool get()
            {
                return (*m_pNativeImagePtr)->IsInUse();
            }
        }

        virtual property unsigned int ImageSize
        {
            unsigned int get()
            {
                return (unsigned int)(*m_pNativeImagePtr)->GetImageSize();
            }
        }

        static String^ GetImageStatusDescription(SpinnakerNET::ImageStatus status);

    private:
        Spinnaker::ImagePtr* m_pNativeImagePtr;
        void UpdateBitmap();
        System::Drawing::Bitmap^ m_bitmap;
        array<byte>^ m_data;

        System::Windows::Media::Imaging::BitmapSource^ m_bitmapsource;
        System::Windows::Media::Imaging::WriteableBitmap^ m_writeablebitmap;
        void UpdateBitmapSource();
        void UpdateWriteAbleBitmap();

    internal:
        Spinnaker::ImagePtr* GetNativeImagePointer();
        ManagedImage(Spinnaker::ImagePtr* pNativeImage);
    };

}

#endif // FLIR_SPINNAKER_MANAGED_IMAGE_H