Zed-Unity插件代码注释——ZEDCamera.CS
@[toc
Zed-Unity插件代码注释——ZEDCamera.cs
引言
Zed-Unity插件提供了在Unity中访问ZED相机SDK的工具，除了提供了SDK的接口外，插件里面还有一些很典型的demo，供开发者参考。
不得不说ZED的文档写的确实很用心， 每个脚本3000多行，但是里面一半以上是注释说明，由于是英文的，看的时候效率较低。
考虑到自己刚刚入门Unity和C#。 有很多知识点需要学，同时也因为现在项目需要的代码量越来越大，一直没有学过程序设计方面的东西，所以打算通读一下这个sdk的代码，顺便学习一些框架类的皮毛。
在通读的代码的过程，也会把里面的注释翻译成中文方便理解，所以就把中文的内容顺手添加到脚本里面去，方便后面自己回看，和后面的人学习。
基础环境
操作系统： Win10 专业版（不是必须的配置，只是习惯性统一写出来）
C# 版本：8.0
Unity版本：2019
Rider版本：2020
ZED型号：ZED-Mini
SDK版本：3.1
ZED-Unity插件版本：3.1
ZedCamera.cs脚本介绍
-
脚本位置：
-
脚本的功能：
这个脚本是插件里面较为底层的脚本，定义了一个命名空间sl,然后定义了一个ZEDCamera的基础类，这个类没有继承Unity的Mono，所以里面没有类似Unity脚本中的 update()、aware()这类型的函数。因此这个脚本在unity中主要是被其他的脚本引用的。在插件里面主要是在ZEDManager.cs中被调用。
这个脚本里面通过[DllImport]引入了SDK的动态链接库(.dll)。并定义了一些在Unity中使用的函数接口，这些函数内部的内容多为调用外部函数（.dll）以实现，只是方便Unity中识别使用。 -
命名空间：sl (在其他脚本中调用这个脚本的时候需要用)
-
类名称：ZEDCamera
-
代码结构:
0~365行：定义了所需要的大部分变量，包括私有和公开的。私有类型的名命规则
365~792行：都是[DllImport]载入动态链接库的代码，以及在C#中对载入函数入口的声明，这部分代码可以不看，基本上是固定的。
792~3040行：定义了一些函数，基本上里面都是调用了前面载入的外部函数。 包括相机参数设定、相机追踪功能、图像数据注册、深度数据注册等等的功能。 这些函数在ZEDManager.cs被调用。更细节的就不在这边展开了，直接从代码里面看吧。
ZedCamera.cs代码(注释后)
//======= Copyright (c) Stereolabs Corporation, All rights reserved. ===============
using UnityEngine;
using System.Collections.Generic;
using System;
using System.Runtime.InteropServices;
using System.Reflection;
namespace sl //定义命名空间
{
/// The ZEDManager component creates a ZEDCamera instance in Awake() and handles all initialization.
/// Most ZED functionality can be handled simply in Unity via ZEDManager or other high-level manager components
/// (ZEDSpatialMappingManager, ZEDPlaneDetectionManager, etc.)
/// Textures created by ZEDCamera by CreateTextureImageType() and CreateTextureMeasureType()
/// are updated automatically by the wrapper whenever a new frame is available. They represent a specific kind of
/// output, like left RGB image, or depth relative to the right sensor. As such, you never need more than one texture
/// of each kind, since it can simply be reused by all scripts that need it. Therefore, textures created in ZEDCamera
/// are indexed by their type (Image or Measure) and then by the options of each type. If a script needs a certain kind
/// of output, ZEDCamera will make a new one if it doesn't exist, but refer to the existing one otherwise.
/// ZEDManager组件在Awake（）中创建一个ZEDCamera实例并处理所有初始化。
/// 大多数ZED功能可以通过ZEDManager或其他高级管理器组件简单地在Unity中处理
/// （（ZEDSpatialMappingManager，ZEDPlaneDetectionManager等）
/// ZEDCamera通过CreateTextureImageType（）和CreateTextureMeasureType（）创建的纹理
/// 只要有新帧，包装器就会自动更新。它们代表一种特定的输出，例如左RGB图像或相对于右传感器的深度。这样，您只需要一个texture就可以
/// 因为它可以被所有需要它的脚本简单地重用。因此，在ZEDCamera中创建的纹理
/// 由其类型（图像或度量）索引，然后由每种类型的选项索引。如果脚本需要某种输出
/// 则ZEDCamera创建一个新的，或者引用现有的输出。
public class ZEDCamera
{
/// Note: the plugin will allow using the original ZED
/// for pass-through but it will feel quite uncomfortable due to the baseline.
/// 该插件将允许使用原始的ZED作为AR的设备，但是由于基线不同，它会让用户感到非常不舒服
/// Lance:最好是用ZED设备的mini版本
public bool IsHmdCompatible //判断AR头盔是否兼容
{
get { return cameraModel == sl.MODEL.ZED_M; }
}
/// The char as a string.
private static string PtrToStringUtf8(IntPtr ptr)
{
if (ptr == IntPtr.Zero)
{
return "";
}
int len = 0;
while (Marshal.ReadByte(ptr, len) != 0)
len++;
if (len == 0)
{
return "";
}
byte[] array = new byte[len];
Marshal.Copy(ptr, array, 0, len);
return System.Text.Encoding.ASCII.GetString(array);
}
/// The array.
private static byte[] StringUtf8ToByte(string str)
{
byte[] array = System.Text.Encoding.ASCII.GetBytes(str);
return array;
}
/// The resolution
static private uint GetFpsForResolution(RESOLUTION reso)
{
if (reso == RESOLUTION.HD1080) return 30;
else if (reso == RESOLUTION.HD2K) return 15;
else if (reso == RESOLUTION.HD720) return 60;
else if (reso == RESOLUTION.VGA) return 100;
return 30;
}
/// A quaternion which contains the matrix's rotation. 。
/// 包含矩阵旋转的四元数 。
public static Quaternion Matrix4ToQuaternion(Matrix4x4 m)
{
Quaternion q = new Quaternion();
q.w = Mathf.Sqrt(Mathf.Max(0, 1 + m[0, 0] + m[1, 1] + m[2, 2])) / 2;
q.x = Mathf.Sqrt(Mathf.Max(0, 1 + m[0, 0] - m[1, 1] - m[2, 2])) / 2;
q.y = Mathf.Sqrt(Mathf.Max(0, 1 - m[0, 0] + m[1, 1] - m[2, 2])) / 2;
q.z = Mathf.Sqrt(Mathf.Max(0, 1 - m[0, 0] - m[1, 1] + m[2, 2])) / 2;
q.x *= Mathf.Sign(q.x * (m[2, 1] - m[1, 2]));
q.y *= Mathf.Sign(q.y * (m[0, 2] - m[2, 0]));
q.z *= Mathf.Sign(q.z * (m[1, 0] - m[0, 1]));
return q;
}
/// True , if USB device connected was found, false otherwise.ERROR_CODE: The error code gives information about the internal connection process.
/// If SUCCESS is returned, the camera is ready to use. Every other code indicates an error.
/// ERROR_CODE：错误代码提供有关内部连接过程的信息。
/// 如果返回SUCCESS，则可以使用相机。其他所有代码均指示错误。
public ERROR_CODE Init(ref InitParameters initParameters) //返回的是错误提示信息
{
//Update values with what we're about to pass to the camera.
//用我们将要传递给相机的值更新值。
currentResolution = initParameters.resolution; //分辨率
fpsMax = GetFpsForResolution(currentResolution); //最大帧率,与当前分辨率有关
if (initParameters.cameraFPS == 0) // 当前帧率是否为0
{
initParameters.cameraFPS = (int) fpsMax; //如果没有指定就直接采用最大的帧率
}
dll_initParameters
initP = new dll_initParameters(
initParameters); //DLL-friendly version of InitParameters. 能够被dll文件接收的参数对象
initP.coordinateSystem =
COORDINATE_SYSTEM
.LEFT_HANDED_Y_UP; //Left-hand, Y-up is Unity's coordinate system, so we match that. 左手系坐标系
int v = dllz_open(CameraID, ref initP,
new System.Text.StringBuilder(initParameters.pathSVO, initParameters.pathSVO.Length),
new System.Text.StringBuilder(initParameters.ipStream, initParameters.ipStream.Length),
initParameters.portStream,
new System.Text.StringBuilder(initParameters.sdkVerboseLogFile,
initParameters.sdkVerboseLogFile.Length),
new System.Text.StringBuilder(initParameters.optionalSettingsPath,
initParameters.optionalSettingsPath
.Length)); // 打开相机，传入相机ID，初始参数的引用, SVO的路径, 流的JP和长度，端口号，sdk的日志文件，最优设置的路径，
if ((ERROR_CODE) v != ERROR_CODE.SUCCESS) //判断是否成功
{
cameraReady = false; //没有成功
return (ERROR_CODE) v; // 返回错误信息 下面的代码不再执行
}
//Set more values if the initialization was successful.
// 如果初始化成功，则设置更多的参数值
imageWidth = dllz_get_width(CameraID); //图片的宽
imageHeight = dllz_get_height(CameraID); //图片的高
if (imageWidth > 0 && imageHeight > 0) //说明相机有返回图片的参数
{
GetCalibrationParameters(false); //获得相机的标定参数 如果为false 就是给calibrationParametersRectified变量赋值一下
FillProjectionMatrix(); // 填充投影变换矩阵,这个函数只需要调用一次
baseline = calibrationParametersRectified.Trans[0]; // 基线赋值
fov_H = calibrationParametersRectified.leftCam.hFOV * Mathf.Deg2Rad; //水平视野
fov_V = calibrationParametersRectified.leftCam.vFOV * Mathf.Deg2Rad; //垂直视野
cameraModel = GetCameraModel(); //获取相机的模型 这边指的是物理相机的模型
cameraReady = true; //相机准备好了
return (ERROR_CODE) v;
}
else
return sl.ERROR_CODE.CAMERA_NOT_INITIALIZED; //未正确启动相机
}
/// For more info, read about the SDK function it calls:
/// 有关更多信息，请阅读有关其调用的SDK函数的信息：
/// https://www.stereolabs.com/developers/documentation/API/v2.5.1/classsl_1_1Camera.html#afa3678a18dd574e162977e97d7cbf67b
/// Struct holding all grab parameters.保留所有抓取参数的结构体
/// the function returns false if no problem was encountered,
/// true otherwise.如果没有遇到问题，该函数返回false，否则返回true。
public sl.ERROR_CODE
Grab(ref sl.RuntimeParameters runtimeParameters) // 发现这个函数并没有返回值，说明只是从上层告知下层相机说你给我采集新的一帧数据，但是采集完的数据并没有返回过来
{
return (sl.ERROR_CODE) dllz_grab(CameraID, ref runtimeParameters);
}
/// An SVO is Stereolabs' own format designed for the ZED. It holds the video feed with timestamps
/// as well as info about the camera used to record it.
/// SVO是Stereolabs自己为ZED设计的格式。它包含带有时间戳的视频，以及有关用于记录它的摄像机的信息。
/// Filename. Whether it ends with .svo or .avi defines its file type.文档名称。它以.svo还是.avi结尾定义其文件类型。
/// How much compression to use,压缩模式
/// An ERROR_CODE that defines if the file was successfully created and can be filled with images.
/// 一个ERROR_CODE，它定义文件是否已成功创建并且可以写入图片数据。
public ERROR_CODE EnableRecording(string videoFileName,
SVO_COMPRESSION_MODE compressionMode = SVO_COMPRESSION_MODE.H264_BASED)
{
return (ERROR_CODE) dllz_enable_recording(CameraID, StringUtf8ToByte(videoFileName), (int) compressionMode);
}
/// Filtering value between 0 and 100.
public int GetConfidenceThreshold()
{
return dllz_get_confidence_threshold(CameraID);
}
/// Current timestamp in nanoseconds. -1 means it's is not available, such as with an .SVO file without compression.
/// 当前时间戳（以纳秒为单位）。 -1表示它不可用，例如未压缩的.SVO文件。
public ulong GetCameraTimeStamp()
{
return dllz_get_camera_timestamp(CameraID);
}
/// The timestamp in nanoseconds.
public ulong GetCurrentTimeStamp()
{
return dllz_get_current_timestamp(CameraID);
}
/// The timestamp in nanoseconds.
public ulong GetImageUpdaterTimeStamp()
{
return dllz_get_image_updater_time_stamp(CameraID);
}
/// Index of the frame being recorded to.
public int GetSVOPosition()
{
return dllz_get_svo_position(CameraID);
}
/// Total frames in the SVO file. Returns -1 if the SDK is not reading an SVO.
public int GetSVONumberOfFrames()
{
return dllz_get_svo_number_of_frames(CameraID);
}
/// The nearest possible depth value.
public float GetDepthMinRangeValue()
{
return dllz_get_depth_min_range_value(CameraID);
}
/// The closest depth
public float GetDepthMaxRangeValue()
{
return dllz_get_depth_max_range_value(CameraID);
}
/// Image type textures are human-viewable, but have less accuracy than measure types.
/// 图像类型的纹理是人类可见的，但其精度低于度量类型。
///
/// Texture2D that will update each frame with the ZED SDK's output.
/// Texture2D将使用ZED SDK的输出更新每个帧。
public Texture2D CreateTextureImageType(VIEW mode, Resolution resolution = new Resolution())
{
if (HasTexture((int) TYPE_VIEW.RETRIEVE_IMAGE, (int) mode))
{
return textures[(int) TYPE_VIEW.RETRIEVE_IMAGE][(int) mode];
}
if (!cameraReady)
return null;
int width = ImageWidth;
int height = imageHeight;
if (!((uint) resolution.width == 0 && (uint) resolution.height == 0)
) //Handles if Resolution arg was empty, as in the default.
{
width = (int) resolution.width;
height = (int) resolution.height;
}
Texture2D m_Texture;
if (mode == VIEW.LEFT_GREY || mode == VIEW.RIGHT_GREY || mode == VIEW.LEFT_UNRECTIFIED_GREY ||
mode == VIEW.RIGHT_UNRECTIFIED_GREY)
{
m_Texture = new Texture2D(width, height, TextureFormat.Alpha8, false);
}
else if (mode == VIEW.SIDE_BY_SIDE)
{
m_Texture = new Texture2D(width * 2, height, TextureFormat.RGBA32,
false); //Needs to be twice as wide for SBS because there are two images.
}
else
{
m_Texture = new Texture2D(width, height, TextureFormat.RGBA32, false);
}
m_Texture.filterMode = FilterMode.Point;
m_Texture.wrapMode = TextureWrapMode.Clamp;
m_Texture.Apply();
IntPtr idTexture = m_Texture.GetNativeTexturePtr();
int error = dllz_register_texture_image_type(CameraID, (int) mode, idTexture, resolution);
if (error != 0)
{
throw new Exception("CUDA error:" + error +
" if the problem appears again, please contact Stereolabs support.");
}
if (!textures.ContainsKey((int) TYPE_VIEW.RETRIEVE_IMAGE))
{
textures.Add((int) TYPE_VIEW.RETRIEVE_IMAGE, new Dictionary<int, Texture2D>());
}
RegisterTexture(m_Texture, (int) TYPE_VIEW.RETRIEVE_IMAGE,
(int) mode); //Save so you don't make a duplicate if another script needs the texture.
return m_Texture;
}
/// Texture2D that will update each frame with the ZED SDK's output.Texture2D将使用ZED SDK的输出更新每个帧。
/// Lance: 这个measure类型的纹理确定就是深度图像，只是模式不同的话，返回的数据类型不同。
public Texture2D CreateTextureMeasureType(MEASURE mode, Resolution resolution = new Resolution())
{
if (HasTexture((int) TYPE_VIEW.RETRIEVE_MEASURE, (int) mode))
{
return textures[(int) TYPE_VIEW.RETRIEVE_MEASURE][(int) mode];
}
if (!cameraReady)
return null;
Texture2D m_Texture;
int width = ImageWidth;
int height = imageHeight;
if (!((uint) resolution.width == 0 && (uint) resolution.height == 0))
{
width = (int) resolution.width;
height = (int) resolution.height;
}
//Handle the mode options.
//不同的数据组织类型,
if (mode == MEASURE.XYZ || mode == MEASURE.XYZABGR || mode == MEASURE.XYZARGB || mode == MEASURE.XYZBGRA ||
mode == MEASURE.XYZRGBA || mode == MEASURE.NORMALS
|| mode == MEASURE.XYZ_RIGHT || mode == MEASURE.XYZABGR_RIGHT || mode == MEASURE.XYZARGB_RIGHT ||
mode == MEASURE.XYZBGRA_RIGHT || mode == MEASURE.XYZRGBA_RIGHT || mode == MEASURE.NORMALS_RIGHT)
{
//这边的类型就是点云的类型,XYZ
m_Texture = new Texture2D(width, height, TextureFormat.RGBAFloat, false, true); //实例化相应的纹理以准备接收相应的纹理数据
}
else if (mode == MEASURE.DEPTH || mode == MEASURE.CONFIDENCE || mode == MEASURE.DISPARITY ||
mode == MEASURE.DEPTH_RIGHT || mode == MEASURE.DISPARITY_RIGHT)
{
// 这边的类型是深度图像的类型
m_Texture = new Texture2D(width, height, TextureFormat.RFloat, false, true);
}
else
{
//这边的类型是彩色图像的类型
m_Texture = new Texture2D(width, height, TextureFormat.RGBA32, false, true);
}
if (!((uint) resolution.width == 0 && (uint) resolution.height == 0)) //确定设置了分辨率
{
m_Texture.filterMode = FilterMode.Bilinear; //双向线性滤波器
}
else
{
m_Texture.filterMode = FilterMode.Point; //点滤波器 这又是啥滤波器
}
m_Texture.wrapMode = TextureWrapMode.Clamp; // 包装的模式为堆类型 这个还不是很懂
m_Texture.Apply(); //应用设置的这些参数
IntPtr idTexture = m_Texture.GetNativeTexturePtr(); //纹理的ID号 这个是什么鬼
int error = dllz_register_texture_measure_type(CameraID, (int) mode, idTexture, resolution); //告诉底层抓取新的数据
if (error != 0) //如果错误
{
throw new Exception("CUDA error:" + error +
" if the problem appears again, please contact Stereolabs support.");
}
if (!textures.ContainsKey((int) TYPE_VIEW.RETRIEVE_MEASURE)) //如果没有包括这个键值
{
textures.Add((int) TYPE_VIEW.RETRIEVE_MEASURE, new Dictionary<int, Texture2D>()); //新添加这个键值对
}
RegisterTexture(m_Texture, (int) TYPE_VIEW.RETRIEVE_MEASURE,
(int) mode); //Save to avoid duplicates if texture type is needed elsewhere.
// 如果在其他位置需要纹理类型，请保存以免重复。
// Lance：就是说 如果需要需要点云数据 或者深度图像的话 在调用这个函数后，应该从 textures这个纹理字典中获得
return m_Texture;
}
/// New ZEDMat for an image texture of the selected view type.就是返回相应的图像矩阵ZEDMat。
public ZEDMat RequestCopyMatFromTextureImageType(sl.VIEW view)
{
return new ZEDMat(dllz_get_copy_mat_texture_image_type(CameraID, (int) view));
}
/// New ZEDMat for a measure texture of the selected measure type.相应的数据矩阵
public ZEDMat RequestCopyMatFromTextureMeasureType(sl.MEASURE measure)
{
return new ZEDMat(dllz_get_copy_mat_texture_measure_type(CameraID, (int) measure));
}
/// Existing texture of the given type/mode.
public Texture2D GetTexture(TYPE_VIEW type, int mode)
{
if (HasTexture((int) type, mode))
{
return textures[(int) type][mode];
}
return null;
}
/// True if the texture is available.
private bool HasTexture(int type, int mode)
{
if (cameraReady) //Texture can't exist if the ZED hasn't been initialized yet.
{
return textures.ContainsKey((int) type) && textures[type].ContainsKey((int) mode);
}
return false;
}
/// The current fps,当前帧率
public float GetCameraFPS()
{
return dllz_get_camera_fps(CameraID);
}
/// Model of the ZED as sl.MODEL.
public sl.MODEL GetCameraModel()
{
return (sl.MODEL) dllz_get_camera_model(CameraID);
}
/// Firmware version.
public int GetCameraFirmwareVersion()
{
return dllz_get_camera_firmware(CameraID);
}
/// Firmware version.
public int GetSensorsFirmwareVersion()
{
return dllz_get_sensors_firmware(CameraID);
}
/// Serial number
public int GetZEDSerialNumber()
{
return dllz_get_zed_serial(CameraID);
}
/// Vertical field of view.
public float GetFOV()
{
return GetCalibrationParameters(false).leftCam.vFOV * Mathf.Deg2Rad;
}
/// Similar to the Frame Drop display in the ZED Explorer app.
/// 类似于ZED Explorer应用程序中的“丢帧”显示。
/// Frames dropped since first Grab() call.
/// 自从第一次Grab（）调用以来，丢掉的帧数。
public uint GetFrameDroppedCount()
{
return dllz_get_frame_dropped_count(CameraID);
}
/// Percentage of frames dropped.
public float GetFrameDroppedPercent()
{
return dllz_get_frame_dropped_percent(CameraID);
}
/// State of ZED's Tracking system (off, searching, ok).
public TRACKING_STATE GetPosition(ref Quaternion rotation, ref Vector3 position,
REFERENCE_FRAME referenceType = REFERENCE_FRAME.WORLD)
{
return (TRACKING_STATE) dllz_get_position(CameraID, ref rotation, ref position, (int) referenceType);
}
/// State of ZED's Tracking system (off, searching, ok).
public TRACKING_STATE GetPosition(ref Quaternion rotation, ref Vector3 translation,
ref Quaternion targetQuaternion, ref Vector3 targetTranslation,
REFERENCE_FRAME referenceFrame = REFERENCE_FRAME.WORLD)
{
return (TRACKING_STATE) dllz_get_position_at_target_frame(CameraID, ref rotation, ref translation,
ref targetQuaternion, ref targetTranslation, (int) referenceFrame);
}
/// State of ZED's Tracking system (off, searching, ok).
public TRACKING_STATE GetPosition(ref Quaternion rotation, ref Vector3 translation,
TRACKING_FRAME trackingFrame, REFERENCE_FRAME referenceFrame = REFERENCE_FRAME.WORLD)
{
Quaternion rotationOffset = Quaternion.identity;
Vector3 positionOffset = Vector3.zero;
switch (trackingFrame) //Add offsets to account for different tracking frames.
{
case sl.TRACKING_FRAME.LEFT_EYE:
positionOffset = new Vector3(0, 0, 0);
break;
case sl.TRACKING_FRAME.RIGHT_EYE:
positionOffset = new Vector3(Baseline, 0, 0);
break;
case sl.TRACKING_FRAME.CENTER_EYE:
positionOffset = new Vector3(Baseline / 2.0f, 0, 0);
break;
}
return (TRACKING_STATE) dllz_get_position_at_target_frame(CameraID, ref rotation, ref translation,
ref rotationOffset, ref positionOffset, (int) referenceFrame);
}
/// State of ZED's Tracking system (off, searching, ok).
public TRACKING_STATE GetPosition(ref Pose pose, REFERENCE_FRAME referenceType = REFERENCE_FRAME.WORLD)
{
return (TRACKING_STATE) dllz_get_position_data(CameraID, ref pose, (int) referenceType);
}
/// Error code status.
/// Prior rotation.
public ERROR_CODE SetIMUOrientationPrior(ref Quaternion rotation)
{
sl.ERROR_CODE trackingStatus = sl.ERROR_CODE.CAMERA_NOT_DETECTED;
trackingStatus = (sl.ERROR_CODE) dllz_set_imu_prior_orientation(CameraID, rotation);
return trackingStatus;
}
/// Error code status.
/// Rotation from the IMU.
public ERROR_CODE GetInternalIMUOrientation(ref Quaternion rotation,
TIME_REFERENCE referenceTime = TIME_REFERENCE.IMAGE)
{
sl.ERROR_CODE err = sl.ERROR_CODE.CAMERA_NOT_DETECTED;
err = (sl.ERROR_CODE) dllz_get_internal_imu_orientation(CameraID, ref rotation, (int) referenceTime);
return err;
}
/// Error code status.
/// Rotation from the IMU.
public ERROR_CODE GetInternalSensorsData(ref SensorsData data,
TIME_REFERENCE referenceTime = TIME_REFERENCE.IMAGE)
{
sl.ERROR_CODE err = sl.ERROR_CODE.CAMERA_NOT_DETECTED;
err = (sl.ERROR_CODE) dllz_get_internal_sensors_data(CameraID, ref data, (int) referenceTime);
return err;
}
/// True if automatic, false if manual.True if automatic, false if manual.The C++ SDK version of this call returns the number of connected ZEDs. But multiple ZEDs aren't supported in the Unity plugin.
/// 此调用的C ++ SDK版本返回已连接ZED的数量。但是Unity插件不支持多个ZED。
/// True if ZED is connected.
public static bool IsZedConnected()
{
return Convert.ToBoolean(dllz_is_zed_connected());
}
/// ZED SDK version as a string in the format MAJOR.MINOR.PATCH.
public static string GetSDKVersion()
{
return PtrToStringUtf8(dllz_get_sdk_version());
}
/// Depth value as a float. 浮点类型的深度值
///
public float GetDepthValue(Vector3 pixel)
{
if (!cameraReady)
{
return -1;
}
//屏幕宽度指的是显示频的屏幕宽度
float posX = (float) ImageWidth * (float) ((float) pixel.x / (float) Screen.width); //这部分的操作是啥,
float posY = ImageHeight * (1 - (float) pixel.y / (float) Screen.height); //这部分的操作是啥，
posX = Mathf.Clamp(posX, 0, ImageWidth); //限制数值的范围，保证稳定性
posY = Mathf.Clamp(posY, 0, ImageHeight);
float d = dllz_get_depth_value(CameraID, (uint) posX, (uint) posY); //这个底层接口其实我们也可以调用，调来获得某个像素的深度值
return d;
}
/// Distance as a float.
/// Lance:这边的输入是电脑屏幕上的像素坐标，不是图像上的像素坐标
///
public float GetDistanceValue(Vector3 pixel)
{
if (!cameraReady) //Do nothing if the ZED isn't initialized.
{
return -1;
}
float posX = ImageWidth * (float) pixel.x / (float) Screen.width;
float posY = ImageHeight * (1 - (float) pixel.y / (float) Screen.height);
posX = Mathf.Clamp(posX, 0, ImageWidth); //把posX限定在这个范围里面，以防万一出现问题
posY = Mathf.Clamp(posY, 0, ImageHeight);
return dllz_get_distance_value(CameraID, (uint) posX, (uint) posY);
}
/// True if successful.
/// Lance：这个是我们需要的，就是获得某个点云点,但是有一个问题就是，这边的输入是屏幕坐标
///
public bool GetXYZValue(Vector3 pixel, out Vector4 xyz)
{
if (!cameraReady) //Do nothing if the ZED isn't initialized.
{
xyz = Vector3.zero;
return false;
}
float posX = (float) ImageWidth * (float) ((float) pixel.x / (float) Screen.width);
float posY = ImageHeight * (1 - (float) pixel.y / (float) Screen.height);
posX = Mathf.Clamp(posX, 0, ImageWidth);
posY = Mathf.Clamp(posY, 0, ImageHeight);
bool r = dllz_get_xyz_value(CameraID, (uint) posX, (uint) posY, out xyz) != 0; //这个函数接口是我们要用的，可以重新定义一下。
return r;
}
/// True if successful.
///
public bool GetNormalValue(Vector3 pixel, out Vector4 normal)
{
if (!cameraReady) //Do nothing if the ZED isn't initialized.
{
normal = Vector3.zero;
return false;
}
float posX = (float) ImageWidth * (float) ((float) pixel.x / (float) Screen.width);
float posY = ImageHeight * (1 - (float) pixel.y / (float) Screen.height);
posX = Mathf.Clamp(posX, 0, ImageWidth);
posY = Mathf.Clamp(posY, 0, ImageHeight);
bool r = dllz_get_normal_value(CameraID, (uint) posX, (uint) posY, out normal) != 0; //某个法向向量
return r;
}
/// Error code indicating if the update was successful, and why it wasn't otherwise.错误代码，指示更新是否成功，以及为什么更新失败。
public sl.ERROR_CODE UpdateMesh(int[] nbVerticesInSubmeshes, int[] nbTrianglesInSubmeshes, ref int nbSubmeshes,
int[] updatedIndices, ref int nbVertices, ref int nbTriangles, int nbSubmeshMax)
{
sl.ERROR_CODE err = sl.ERROR_CODE.FAILURE;
err = (sl.ERROR_CODE) dllz_update_mesh(CameraID, nbVerticesInSubmeshes, nbTrianglesInSubmeshes,
ref nbSubmeshes, updatedIndices, ref nbVertices, ref nbTriangles, nbSubmeshMax);
return err;
}
/// Error code indicating if the retrieval was successful, and why it wasn't otherwise.
public sl.ERROR_CODE RetrieveMesh(Vector3[] vertices, int[] triangles, int nbSubmeshMax, Vector2[] uvs,
IntPtr textures)
{
return (sl.ERROR_CODE) dllz_retrieve_mesh(CameraID, vertices, triangles, nbSubmeshMax, uvs, textures);
}
/// Vector3 pointing downward.
public Vector3 GetGravityEstimate()
{
Vector3 v = Vector3.zero;
dllz_spatial_mapping_get_gravity_estimation(CameraID, ref v);
return v;
}
/// Error code indicating if the retrieval was successful, and why it wasn't otherwise.
public sl.ERROR_CODE RetrieveMeasure(sl.ZEDMat mat, sl.MEASURE measure,
sl.ZEDMat.MEM mem = sl.ZEDMat.MEM.MEM_CPU, sl.Resolution resolution = new sl.Resolution())
{
return (sl.ERROR_CODE) (dllz_retrieve_measure(CameraID, mat.MatPtr, (int) measure, (int) mem, resolution));
}
/// Error code indicating if the retrieval was successful, and why it wasn't otherwise.
public sl.ERROR_CODE RetrieveImage(sl.ZEDMat mat, sl.VIEW view, sl.ZEDMat.MEM mem = sl.ZEDMat.MEM.MEM_CPU,
sl.Resolution resolution = new sl.Resolution())
{
return (sl.ERROR_CODE) (dllz_retrieve_image(CameraID, mat.MatPtr, (int) view, (int) mem, resolution));
}
/// An ERROR_CODE that defines if the streaming pipe was successfully created
/// 一个ERROR_CODE，定义是否成功创建了流管道
public ERROR_CODE EnableStreaming(STREAMING_CODEC codec = STREAMING_CODEC.AVCHD_BASED, uint bitrate = 8000,
ushort port = 30000, int gopSize = -1, bool adaptativeBitrate = false, int chunk_size = 32768)
{
int doAdaptBitrate = adaptativeBitrate ? 1 : 0;
return (ERROR_CODE) dllz_enable_streaming(CameraID, codec, bitrate, port, gopSize, doAdaptBitrate,
chunk_size);
}
/// false if streaming is not enabled, true if streaming is on
public bool IsStreamingEnabled()
{
int res = dllz_is_streaming_enabled(CameraID);
if (res == 1)
return true;
else
return false;
}
///