875 lines
40 KiB
C#
875 lines
40 KiB
C#
//======= Copyright (c) Stereolabs Corporation, All rights reserved. ===============
|
|
using System;
|
|
using System.Runtime.InteropServices;
|
|
|
|
/// <summary>
|
|
/// This file holds the ZEDMat class along with low-level structures used for passing data between
|
|
/// the C# ZEDMat and its equivalent in the SDK.
|
|
/// </summary>
|
|
|
|
namespace sl
|
|
{
|
|
/// <summary>
|
|
/// Represents a 2D vector of uchars for use on both the CPU and GPU.
|
|
/// </summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct char2
|
|
{
|
|
public byte r;
|
|
public byte g;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents a 3D vector of uchars for use on both the CPU and GPU.
|
|
/// </summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct char3
|
|
{
|
|
public byte r;
|
|
public byte g;
|
|
public byte b;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents a 4D vector of uchars for use on both the CPU and GPU.
|
|
/// </summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct char4
|
|
{
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte r;
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte g;
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte b;
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte a;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents a 2D vector of floats for use on both the CPU and GPU.
|
|
/// </summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct float2
|
|
{
|
|
public float r;
|
|
public float g;
|
|
}
|
|
/// <summary>
|
|
/// Represents a 3D vector of floats for use on both the CPU and GPU.
|
|
/// </summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct float3
|
|
{
|
|
public float r;
|
|
public float g;
|
|
public float b;
|
|
}
|
|
/// <summary>
|
|
/// Represents a 4D vector of floats for use on both the CPU and GPU.
|
|
/// </summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct float4
|
|
{
|
|
public float r;
|
|
public float g;
|
|
public float b;
|
|
public float a;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Mirrors the sl::Mat class used in the ZED C++ SDK to store images.
|
|
/// Can be used to retrieve individual images from GPU or CPU memory: see ZEDCamera.RetrieveImage()
|
|
/// and ZEDCamera.RetrieveMeasure().
|
|
/// </summary><remarks>
|
|
/// For more information on the Mat class it mirrors, see:
|
|
/// https://www.stereolabs.com/developers/documentation/API/v2.5.1/classsl_1_1Mat.html
|
|
/// </remarks>
|
|
public class ZEDMat
|
|
{
|
|
/// <summary>
|
|
/// Type of mat, indicating the data type and the number of channels it holds.
|
|
/// Proper mat type depends on the image type. See sl.VIEW and sl.MEASURE (in ZEDCommon.cs)
|
|
/// </summary>
|
|
public enum MAT_TYPE
|
|
{
|
|
/// <summary>
|
|
/// Float, one channel. Used for depth and disparity Measure-type textures.
|
|
/// </summary>
|
|
MAT_32F_C1,
|
|
/// <summary>
|
|
/// Float, two channels.
|
|
/// </summary>
|
|
MAT_32F_C2,
|
|
/// <summary>
|
|
/// Float, three channels.
|
|
/// </summary>
|
|
MAT_32F_C3, /*!< float 3 channels.*/
|
|
/// <summary>
|
|
/// Float, four channels. Used for normals and XYZ (point cloud) measure-type textures
|
|
/// </summary>
|
|
MAT_32F_C4,
|
|
/// <summary>
|
|
/// Unsigned char, one channel. Used for greyscale image-type textures like depth and confidence displays.
|
|
/// </summary>
|
|
MAT_8U_C1,
|
|
/// <summary>
|
|
/// Unsigned char, two channels.
|
|
/// </summary>
|
|
MAT_8U_C2,
|
|
/// <summary>
|
|
/// Unsigned char, three channels.
|
|
/// </summary>
|
|
MAT_8U_C3,
|
|
/// <summary>
|
|
/// Unsigned char, four channels. Used for color images, like the main RGB image from each sensor.
|
|
/// </summary>
|
|
MAT_8U_C4
|
|
};
|
|
|
|
/// <summary>
|
|
/// Categories for copying data within or between the CPU (processor) memory and GPU (graphics card) memory.
|
|
/// </summary>
|
|
public enum COPY_TYPE
|
|
{
|
|
/// <summary>
|
|
/// Copies data from one place in CPU memory to another.
|
|
/// </summary>
|
|
COPY_TYPE_CPU_CPU, /*!< copy data from CPU to CPU.*/
|
|
/// <summary>
|
|
/// Copies data from CPU memory to GPU memory.
|
|
/// </summary>
|
|
COPY_TYPE_CPU_GPU, /*!< copy data from CPU to GPU.*/
|
|
/// <summary>
|
|
/// Copies data from one place in GPU memory to another.
|
|
/// </summary>
|
|
COPY_TYPE_GPU_GPU, /*!< copy data from GPU to GPU.*/
|
|
/// <summary>
|
|
/// Copies data from GPU memory to CPU memory.
|
|
/// </summary>
|
|
COPY_TYPE_GPU_CPU /*!< copy data from GPU to CPU.*/
|
|
};
|
|
|
|
/// <summary>
|
|
/// Which memory to store an image/mat: CPU/processor memory or GPU (graphics card) memory.
|
|
/// </summary>
|
|
public enum MEM
|
|
{
|
|
/// <summary>
|
|
/// Store on memory accessible by the CPU.
|
|
/// </summary>
|
|
MEM_CPU = 1,
|
|
/// <summary>
|
|
/// Store on memory accessible by the GPU.
|
|
/// </summary>
|
|
MEM_GPU = 2
|
|
};
|
|
|
|
#region DLL Calls
|
|
const string nameDll = "sl_unitywrapper";
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_create_new")]
|
|
private static extern IntPtr dllz_mat_create_new(sl.Resolution resolution, int type, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_create_new_empty")]
|
|
private static extern IntPtr dllz_mat_create_new_empty();
|
|
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_is_init")]
|
|
private static extern bool dllz_mat_is_init(System.IntPtr ptr);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_free")]
|
|
private static extern bool dllz_mat_free(System.IntPtr ptr, int type);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_infos")]
|
|
private static extern bool dllz_mat_get_infos(System.IntPtr ptr, byte[] buffer);
|
|
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_value_float")]
|
|
private static extern int dllz_mat_get_value_float(System.IntPtr ptr, int x, int y, out float value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_value_float2")]
|
|
private static extern int dllz_mat_get_value_float2(System.IntPtr ptr, int x, int y, out float2 value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_value_float3")]
|
|
private static extern int dllz_mat_get_value_float3(System.IntPtr ptr, int x, int y, out float3 value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_value_float4")]
|
|
private static extern int dllz_mat_get_value_float4(System.IntPtr ptr, int x, int y, out float4 value, int mem);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_value_uchar")]
|
|
private static extern int dllz_mat_get_value_uchar(System.IntPtr ptr, int x, int y, out byte value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_value_uchar2")]
|
|
private static extern int dllz_mat_get_value_uchar2(System.IntPtr ptr, int x, int y, out char2 value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_value_uchar3")]
|
|
private static extern int dllz_mat_get_value_uchar3(System.IntPtr ptr, int x, int y, out char3 value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_value_uchar4")]
|
|
private static extern int dllz_mat_get_value_uchar4(System.IntPtr ptr, int x, int y, out char4 value, int mem);
|
|
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_value_float")]
|
|
private static extern int dllz_mat_set_value_float(System.IntPtr ptr, int x, int y, ref float value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_value_float2")]
|
|
private static extern int dllz_mat_set_value_float2(System.IntPtr ptr, int x, int y, ref float2 value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_value_float3")]
|
|
private static extern int dllz_mat_set_value_float3(System.IntPtr ptr, int x, int y, ref float3 value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_value_float4")]
|
|
private static extern int dllz_mat_set_value_float4(System.IntPtr ptr, int x, int y, ref float4 value, int mem);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_value_uchar")]
|
|
private static extern int dllz_mat_set_value_uchar(System.IntPtr ptr, int x, int y, ref byte value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_value_uchar2")]
|
|
private static extern int dllz_mat_set_value_uchar2(System.IntPtr ptr, int x, int y, ref char2 value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_value_uchar3")]
|
|
private static extern int dllz_mat_set_value_uchar3(System.IntPtr ptr, int x, int y, ref char3 value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_value_uchar4")]
|
|
private static extern int dllz_mat_set_value_uchar4(System.IntPtr ptr, int x, int y, ref char4 value, int mem);
|
|
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_to_float")]
|
|
private static extern int dllz_mat_set_to_float(System.IntPtr ptr, ref float value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_to_float2")]
|
|
private static extern int dllz_mat_set_to_float2(System.IntPtr ptr, ref float2 value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_to_float3")]
|
|
private static extern int dllz_mat_set_to_float3(System.IntPtr ptr, ref float3 value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_to_float4")]
|
|
private static extern int dllz_mat_set_to_float4(System.IntPtr ptr, ref float4 value, int mem);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_to_uchar")]
|
|
private static extern int dllz_mat_set_to_uchar(System.IntPtr ptr, ref byte value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_to_uchar2")]
|
|
private static extern int dllz_mat_set_to_uchar2(System.IntPtr ptr, ref char2 value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_to_uchar3")]
|
|
private static extern int dllz_mat_set_to_uchar3(System.IntPtr ptr, ref char3 value, int mem);
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_to_uchar4")]
|
|
private static extern int dllz_mat_set_to_uchar4(System.IntPtr ptr, ref char4 value, int mem);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_update_cpu_from_gpu")]
|
|
private static extern int dllz_mat_update_cpu_from_gpu(System.IntPtr ptr);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_update_gpu_from_cpu")]
|
|
private static extern int dllz_mat_update_gpu_from_cpu(System.IntPtr ptr);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_read")]
|
|
private static extern int dllz_mat_read(System.IntPtr ptr, string filePath);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_write")]
|
|
private static extern int dllz_mat_write(System.IntPtr ptr, string filePath);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_copy_to")]
|
|
private static extern int dllz_mat_copy_to(System.IntPtr ptr, System.IntPtr dest, int cpyType);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_width")]
|
|
private static extern int dllz_mat_get_width(System.IntPtr ptr);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_height")]
|
|
private static extern int dllz_mat_get_height(System.IntPtr ptr);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_channels")]
|
|
private static extern int dllz_mat_get_channels(System.IntPtr ptr);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_memory_type")]
|
|
private static extern int dllz_mat_get_memory_type(System.IntPtr ptr);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_pixel_bytes")]
|
|
private static extern int dllz_mat_get_pixel_bytes(System.IntPtr ptr);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_step")]
|
|
private static extern int dllz_mat_get_step(System.IntPtr ptr);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_step_bytes")]
|
|
private static extern int dllz_mat_get_step_bytes(System.IntPtr ptr);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_width_bytes")]
|
|
private static extern int dllz_mat_get_width_bytes(System.IntPtr ptr);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_is_memory_owner")]
|
|
private static extern bool dllz_mat_is_memory_owner(System.IntPtr ptr);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_resolution")]
|
|
private static extern sl.Resolution dllz_mat_get_resolution(System.IntPtr ptr);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_alloc")]
|
|
private static extern void dllz_mat_alloc(System.IntPtr ptr, int width, int height, int type, int mem);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_set_from")]
|
|
private static extern int dllz_mat_set_from(System.IntPtr ptr, System.IntPtr source, int copyType);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_get_ptr")]
|
|
private static extern System.IntPtr dllz_mat_get_ptr(System.IntPtr ptr, int mem);
|
|
|
|
[DllImport(nameDll, EntryPoint = "dllz_mat_clone")]
|
|
private static extern void dllz_mat_clone(System.IntPtr ptr, System.IntPtr ptrSource);
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Returns the internal ptr of a Mat.
|
|
/// </summary>
|
|
private System.IntPtr _matInternalPtr;
|
|
/// <summary>
|
|
/// Returns the internal ptr of a Mat.
|
|
/// </summary>
|
|
public IntPtr MatPtr
|
|
{
|
|
get { return _matInternalPtr; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates an empty Mat.
|
|
/// </summary>
|
|
public ZEDMat()
|
|
{
|
|
_matInternalPtr = dllz_mat_create_new_empty();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a mat from an existing internal ptr.
|
|
/// </summary>
|
|
/// <param name="ptr">IntPtr to create the material with.</param>
|
|
public ZEDMat(System.IntPtr ptr)
|
|
{
|
|
if(ptr == IntPtr.Zero)
|
|
{
|
|
throw new Exception("ZED Mat not initialized.");
|
|
}
|
|
_matInternalPtr = ptr;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a Mat with a given resolution.
|
|
/// </summary>
|
|
/// <param name="resolution">Resolution for the new Mat.</param>
|
|
/// <param name="type">Data type and number of channels the Mat will hold.
|
|
/// Depends on texture type: see sl.VIEW and sl.MEASURE in ZEDCommon.cs.</param>
|
|
/// <param name="mem">Whether Mat should exist on CPU or GPU memory.
|
|
/// Choose depending on where you'll need to access it from.</param>
|
|
public ZEDMat(sl.Resolution resolution, MAT_TYPE type, MEM mem = MEM.MEM_CPU)
|
|
{
|
|
_matInternalPtr = dllz_mat_create_new(resolution, (int)(type), (int)(mem));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a Mat with a given width and height.
|
|
/// </summary>
|
|
/// <param name="width">Width of the new Mat.</param>
|
|
/// <param name="height">Height of the new Mat.</param>
|
|
/// <param name="type">Data type and number of channels the Mat will hold.
|
|
/// Depends on texture type: see sl.VIEW and sl.MEASURE in ZEDCommon.cs.</param>
|
|
/// <param name="mem">Whether Mat should exist on CPU or GPU memory.
|
|
/// Choose depending on where you'll need to access it from.</param>
|
|
public ZEDMat(uint width, uint height, MAT_TYPE type, MEM mem = MEM.MEM_CPU)
|
|
{
|
|
_matInternalPtr = dllz_mat_create_new(new sl.Resolution(width, height), (int)(type), (int)(mem));
|
|
}
|
|
|
|
/// <summary>
|
|
/// True if the Mat has been initialized.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool IsInit()
|
|
{
|
|
return dllz_mat_is_init(_matInternalPtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Frees the memory of the Mat.
|
|
/// </summary>
|
|
/// <param name="mem">Whether the Mat is on CPU or GPU memory.</param>
|
|
public void Free(MEM mem = (MEM.MEM_GPU | MEM.MEM_CPU))
|
|
{
|
|
dllz_mat_free(_matInternalPtr, (int)mem);
|
|
_matInternalPtr = System.IntPtr.Zero;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies data from the GPU to the CPU, if possible.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public sl.ERROR_CODE UpdateCPUFromGPU()
|
|
{
|
|
return (sl.ERROR_CODE)dllz_mat_update_cpu_from_gpu(_matInternalPtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies data from the CPU to the GPU, if possible.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public sl.ERROR_CODE UpdateGPUFromCPU()
|
|
{
|
|
return (sl.ERROR_CODE)dllz_mat_update_gpu_from_cpu(_matInternalPtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns information about the Mat.
|
|
/// </summary>
|
|
/// <returns>String providing Mat information.</returns>
|
|
public string GetInfos()
|
|
{
|
|
byte[] buf = new byte[300];
|
|
dllz_mat_get_infos(_matInternalPtr, buf);
|
|
return System.Text.Encoding.ASCII.GetString(buf);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies data from this Mat to another Mat (deep copy).
|
|
/// </summary>
|
|
/// <param name="dest">Mat that the data will be copied to.</param>
|
|
/// <param name="copyType">The To and From memory types.</param>
|
|
/// <returns>Error code indicating if the copy was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE CopyTo(sl.ZEDMat dest, sl.ZEDMat.COPY_TYPE copyType = COPY_TYPE.COPY_TYPE_CPU_CPU)
|
|
{
|
|
return (sl.ERROR_CODE)dllz_mat_copy_to(_matInternalPtr, dest._matInternalPtr, (int)(copyType));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads an image from a file. Supports .png and .jpeg. Only works if Mat has access to MEM_CPU.
|
|
/// </summary>
|
|
/// <param name="filePath">File path, including file name and extension.</param>
|
|
/// <returns>Error code indicating if the read was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE Read(string filePath)
|
|
{
|
|
return (sl.ERROR_CODE)dllz_mat_read(_matInternalPtr, filePath);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes the Mat into a file as an image. Only works if Mat has access to MEM_CPU.
|
|
/// </summary>
|
|
/// <param name="filePath">File path, including file name and extension.</param>
|
|
/// <returns>Error code indicating if the write was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE Write(string filePath)
|
|
{
|
|
return (sl.ERROR_CODE)dllz_mat_write(_matInternalPtr, filePath);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the width of the matrix.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public int GetWidth()
|
|
{
|
|
return dllz_mat_get_width(_matInternalPtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the height of the matrix.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public int GetHeight()
|
|
{
|
|
return dllz_mat_get_height(_matInternalPtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the number of values/channels stored in each pixel.
|
|
/// </summary>
|
|
/// <returns>Number of values/channels.</returns>
|
|
public int GetChannels()
|
|
{
|
|
return dllz_mat_get_channels(_matInternalPtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the size in bytes of one pixel.
|
|
/// </summary>
|
|
/// <returns>Size in bytes.</returns>
|
|
public int GetPixelBytes()
|
|
{
|
|
return dllz_mat_get_pixel_bytes(_matInternalPtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the memory 'step' in number/length of elements - how many values make up each row of pixels.
|
|
/// </summary>
|
|
/// <returns>Step length.</returns>
|
|
public int GetStep()
|
|
{
|
|
return dllz_mat_get_step(_matInternalPtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the memory 'step' in bytes - how many bytes make up each row of pixels.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public int GetStepBytes()
|
|
{
|
|
return dllz_mat_get_step_bytes(_matInternalPtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the size of each row in bytes.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public int GetWidthBytes()
|
|
{
|
|
return dllz_mat_get_width_bytes(_matInternalPtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the type of memory (CPU and/or GPU).
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public MEM GetMemoryType()
|
|
{
|
|
return (MEM)dllz_mat_get_memory_type(_matInternalPtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns whether the Mat is the owner of the memory it's accessing.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool IsMemoryOwner()
|
|
{
|
|
return dllz_mat_is_memory_owner(_matInternalPtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the resolution of the image that this Mat holds.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public sl.Resolution GetResolution()
|
|
{
|
|
return dllz_mat_get_resolution(_matInternalPtr);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Allocates memory for the Mat.
|
|
/// </summary>
|
|
/// <param name="width">Width of the image/matrix in pixels.</param>
|
|
/// <param name="height">Height of the image/matrix in pixels.</param>
|
|
/// <param name="matType">Type of matrix (data type and channels; see sl.MAT_TYPE)</param>
|
|
/// <param name="mem">Where the buffer will be stored - CPU memory or GPU memory.</param>
|
|
public void Alloc(uint width, uint height, MAT_TYPE matType, MEM mem = MEM.MEM_CPU)
|
|
{
|
|
dllz_mat_alloc(_matInternalPtr, (int)width, (int)height, (int)matType, (int)mem);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Allocates memory for the Mat.
|
|
/// </summary>
|
|
/// <param name="resolution">Size of the image/matrix in pixels.</param>
|
|
/// <param name="matType">Type of matrix (data type and channels; see sl.MAT_TYPE)</param>
|
|
/// <param name="mem">Where the buffer will be stored - CPU memory or GPU memory.</param>
|
|
public void Alloc(sl.Resolution resolution, MAT_TYPE matType, MEM mem = MEM.MEM_CPU)
|
|
{
|
|
dllz_mat_alloc(_matInternalPtr, (int)resolution.width, (int)resolution.height, (int)matType, (int)mem);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies data from another Mat into this one(deep copy).
|
|
/// </summary>
|
|
/// <param name="src">Source Mat from which to copy.</param>
|
|
/// <param name="copyType">The To and From memory types.</param>
|
|
/// <returns>ERROR_CODE (as an int) indicating if the copy was successful, or why it wasn't.</returns>
|
|
public int SetFrom(ZEDMat src, COPY_TYPE copyType = COPY_TYPE.COPY_TYPE_CPU_CPU)
|
|
{
|
|
return dllz_mat_set_from(_matInternalPtr, src._matInternalPtr, (int)copyType);
|
|
}
|
|
|
|
public System.IntPtr GetPtr(MEM mem = MEM.MEM_CPU)
|
|
{
|
|
return dllz_mat_get_ptr(_matInternalPtr, (int)mem);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Duplicates a Mat by copying all its data into a new one (deep copy).
|
|
/// </summary>
|
|
/// <param name="source"></param>
|
|
public void Clone(ZEDMat source)
|
|
{
|
|
dllz_mat_clone(_matInternalPtr, source._matInternalPtr);
|
|
}
|
|
|
|
/************ GET VALUES *********************/
|
|
//Cannot send values by template due to a covariant issue with an out needed.
|
|
|
|
/// <summary>
|
|
/// Returns the value of a specific point in the matrix. (MAT_32F_C1)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Gets filled with the current value.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the get was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE GetValue(int x, int y, out float value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_get_value_float(_matInternalPtr, x, y, out value, (int)(mem)));
|
|
}
|
|
/// <summary>
|
|
/// Returns the value of a specific point in the matrix. (MAT_32F_C2)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Gets filled with the current value.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the get was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE GetValue(int x, int y, out float2 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_get_value_float2(_matInternalPtr, x, y, out value, (int)(mem)));
|
|
}
|
|
/// <summary>
|
|
/// Returns the value of a specific point in the matrix. (MAT_32F_C3)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Gets filled with the current value.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the get was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE GetValue(int x, int y, out float3 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_get_value_float3(_matInternalPtr, x, y, out value, (int)(mem)));
|
|
}
|
|
/// <summary>
|
|
/// Returns the value of a specific point in the matrix. (MAT_32F_C4)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Gets filled with the current value.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the get was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE GetValue(int x, int y, out float4 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_get_value_float4(_matInternalPtr, x, y, out value, (int)(mem)));
|
|
}
|
|
/// <summary>
|
|
/// Returns the value of a specific point in the matrix. (MAT_TYPE_8U_C1)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Gets filled with the current value.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the get was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE GetValue(int x, int y, out byte value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_get_value_uchar(_matInternalPtr, x, y, out value, (int)(mem)));
|
|
}
|
|
/// <summary>
|
|
/// Returns the value of a specific point in the matrix. (MAT_TYPE_8U_C2)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Gets filled with the current value.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the get was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE GetValue(int x, int y, out char2 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_get_value_uchar2(_matInternalPtr, x, y, out value, (int)(mem)));
|
|
}
|
|
/// <summary>
|
|
/// Returns the value of a specific point in the matrix. (MAT_TYPE_8U_C3)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Gets filled with the current value.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the get was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE GetValue(int x, int y, out char3 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_get_value_uchar3(_matInternalPtr, x, y, out value, (int)(mem)));
|
|
}
|
|
/// <summary>
|
|
/// Returns the value of a specific point in the matrix. (MAT_TYPE_8U_C4)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Gets filled with the current value.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the get was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE GetValue(int x, int y, out char4 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_get_value_uchar4(_matInternalPtr, x, y, out value, (int)(mem)));
|
|
}
|
|
/***************************************************************************************/
|
|
|
|
|
|
/************ SET VALUES *********************/
|
|
//Cannot send values by template due to a covariant issue with an out needed.
|
|
|
|
/// <summary>
|
|
/// Sets a value to a specific point in the matrix. (MAT_32F_C1)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Value to which the point will be set.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetValue(int x, int y, ref float value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_value_float(_matInternalPtr, x, y, ref value, (int)(mem)));
|
|
}
|
|
/// <summary>
|
|
/// Sets a value to a specific point in the matrix. (MAT_32F_C2)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Value to which the point will be set.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetValue(int x, int y, ref float2 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_value_float2(_matInternalPtr, x, y, ref value, (int)(mem)));
|
|
}
|
|
/// <summary>
|
|
/// Sets a value to a specific point in the matrix. (MAT_32F_C3)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Value to which the point will be set.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetValue(int x, int y, ref float3 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_value_float3(_matInternalPtr, x, y, ref value, (int)(mem)));
|
|
}
|
|
/// <summary>
|
|
/// Sets a value to a specific point in the matrix. (MAT_32F_C4)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Value to which the point will be set.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetValue(int x, int y, float4 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_value_float4(_matInternalPtr, x, y, ref value, (int)(mem)));
|
|
}
|
|
/// <summary>
|
|
/// Sets a value to a specific point in the matrix. (MAT_TYPE_8U_C1)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Value to which the point will be set.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetValue(int x, int y, ref byte value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_value_uchar(_matInternalPtr, x, y, ref value, (int)(mem)));
|
|
}
|
|
/// <summary>
|
|
/// Sets a value to a specific point in the matrix. (MAT_TYPE_8U_C2)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Value to which the point will be set.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetValue(int x, int y, ref char2 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_value_uchar2(_matInternalPtr, x, y, ref value, (int)(mem)));
|
|
}
|
|
/// <summary>
|
|
/// Sets a value to a specific point in the matrix. (MAT_TYPE_8U_C3)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Value to which the point will be set.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetValue(int x, int y, ref char3 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_value_uchar3(_matInternalPtr, x, y, ref value, (int)(mem)));
|
|
}
|
|
/// <summary>
|
|
/// Sets a value to a specific point in the matrix. (MAT_TYPE_8U_C4)
|
|
/// </summary>
|
|
/// <param name="x">Row the point is in.</param>
|
|
/// <param name="y">Column the point is in.</param>
|
|
/// <param name="value">Value to which the point will be set.</param>
|
|
/// <param name="mem">Whether point is on CPU memory or GPU memory.</param>
|
|
/// <returns>Error code indicating if the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetValue(int x, int y, ref char4 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_value_uchar4(_matInternalPtr, x, y, ref value, (int)(mem)));
|
|
}
|
|
/***************************************************************************************/
|
|
|
|
/************ SET TO *********************/
|
|
//Cannot send values by template due to a covariant issue with an out needed.
|
|
|
|
/// <summary>
|
|
/// Fills the entire Mat with the given value. (MAT_32F_C1)
|
|
/// </summary>
|
|
/// <param name="value">Value with which to fill the Mat.</param>
|
|
/// <param name="mem">Which buffer to fill - CPU or GPU memory.</param>
|
|
/// <returns>Whether the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetTo(ref float value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_to_float(_matInternalPtr, ref value, (int)(mem)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fills the entire Mat with the given value. (MAT_32F_C2)
|
|
/// </summary>
|
|
/// <param name="value">Value with which to fill the Mat.</param>
|
|
/// <param name="mem">Which buffer to fill - CPU or GPU memory.</param>
|
|
/// <returns>Whether the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetTo(ref float2 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_to_float2(_matInternalPtr, ref value, (int)(mem)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fills the entire Mat with the given value. (MAT_32F_C3)
|
|
/// </summary>
|
|
/// <param name="value">Value with which to fill the Mat.</param>
|
|
/// <param name="mem">Which buffer to fill - CPU or GPU memory.</param>
|
|
/// <returns>Whether the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetTo(ref float3 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_to_float3(_matInternalPtr, ref value, (int)(mem)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fills the entire Mat with the given value. (MAT_32F_C4)
|
|
/// </summary>
|
|
/// <param name="value">Value with which to fill the Mat.</param>
|
|
/// <param name="mem">Which buffer to fill - CPU or GPU memory.</param>
|
|
/// <returns>Whether the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetTo(ref float4 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_to_float4(_matInternalPtr, ref value, (int)(mem)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fills the entire Mat with the given value. (MAT_TYPE_8U_C1)
|
|
/// </summary>
|
|
/// <param name="value">Value with which to fill the Mat.</param>
|
|
/// <param name="mem">Which buffer to fill - CPU or GPU memory.</param>
|
|
/// <returns>Whether the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetTo(ref byte value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_to_uchar(_matInternalPtr, ref value, (int)(mem)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fills the entire Mat with the given value. (MAT_TYPE_8U_C2)
|
|
/// </summary>
|
|
/// <param name="value">Value with which to fill the Mat.</param>
|
|
/// <param name="mem">Which buffer to fill - CPU or GPU memory.</param>
|
|
/// <returns>Whether the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetTo(ref char2 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_to_uchar2(_matInternalPtr, ref value, (int)(mem)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fills the entire Mat with the given value. (MAT_TYPE_8U_C3)
|
|
/// </summary>
|
|
/// <param name="value">Value with which to fill the Mat.</param>
|
|
/// <param name="mem">Which buffer to fill - CPU or GPU memory.</param>
|
|
/// <returns>Whether the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetTo(ref char3 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_to_uchar3(_matInternalPtr, ref value, (int)(mem)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fills the entire Mat with the given value. (MAT_TYPE_8U_C4)
|
|
/// </summary>
|
|
/// <param name="value">Value with which to fill the Mat.</param>
|
|
/// <param name="mem">Which buffer to fill - CPU or GPU memory.</param>
|
|
/// <returns>Whether the set was successful, or why it wasn't.</returns>
|
|
public sl.ERROR_CODE SetTo( ref char4 value, sl.ZEDMat.MEM mem)
|
|
{
|
|
return (sl.ERROR_CODE)(dllz_mat_set_to_uchar4(_matInternalPtr, ref value, (int)(mem)));
|
|
}
|
|
/***************************************************************************************/
|
|
|
|
}
|
|
}
|