/// <summary>
/// Transforms an Image from the color camera perspective to the depth camera perspective.
/// </summary>
/// <param name="depth">Depth map of the space the color image is being transformed in to.</param>
/// <param name="color">Color image to transform in to the depth space.</param>
/// <param name="transformed">An Image to hold the output.</param>
/// <remarks>
/// The <paramref name="transformed"/> Image must be of the resolution of the depth camera, and
/// of the pixel format of the color image.
/// </remarks>
public void ColorImageToDepthCamera(Image depth, Image color, Image transformed)
{
if (depth == null)
{
throw new ArgumentNullException(nameof(depth));
}
if (color == null)
{
throw new ArgumentNullException(nameof(color));
}
if (transformed == null)
{
throw new ArgumentNullException(nameof(transformed));
}
lock (this)
{
if (this.disposedValue)
{
throw new ObjectDisposedException(nameof(Transformation));
}
// Create a new reference to the Image objects so that they cannot be disposed while
// we are performing the transformation
using (Image depthReference = depth.Reference())
using (Image colorReference = color.Reference())
using (Image transformedReference = transformed.Reference())
{
// Ensure changes made to the managed memory are visible to the native layer
depthReference.FlushMemory();
colorReference.FlushMemory();
AzureKinectException.ThrowIfNotSuccess(() => NativeMethods.k4a_transformation_color_image_to_depth_camera(
this.handle,
depthReference.DangerousGetHandle(),
colorReference.DangerousGetHandle(),
transformedReference.DangerousGetHandle()));
// Copy the native memory back to managed memory if required
transformedReference.InvalidateMemory();
}
}
}
/// <summary>
/// Creates a point cloud from a depth image.
/// </summary>
/// <param name="depth">The depth map to generate the point cloud from.</param>
/// <param name="pointCloud">The image to store the output point cloud.</param>
/// <param name="camera">The perspective the depth map is from.</param>
/// <remarks>
/// If the depth map is from the original depth perspective, <paramref name="camera"/> should be Depth. If it has
/// been transformed to the color camera perspective, <paramref name="camera"/> should be Color.
///
/// The <paramref name="pointCloud"/> image must be of format Custom. Each pixel will be an XYZ set of 16 bit values,
/// therefore its stride must be 2(bytes) * 3(x,y,z) * width of the <paramref name="depth"/> image in pixels.
/// </remarks>
public void DepthImageToPointCloud(Image depth, Image pointCloud, CalibrationDeviceType camera = CalibrationDeviceType.Depth)
{
if (depth == null)
{
throw new ArgumentNullException(nameof(depth));
}
if (pointCloud == null)
{
throw new ArgumentNullException(nameof(pointCloud));
}
lock (this)
{
if (this.disposedValue)
{
throw new ObjectDisposedException(nameof(Transformation));
}
// Create a new reference to the Image objects so that they cannot be disposed while
// we are performing the transformation
using (Image depthReference = depth.Reference())
using (Image pointCloudReference = pointCloud.Reference())
{
// Ensure changes made to the managed memory are visible to the native layer
depthReference.FlushMemory();
AzureKinectException.ThrowIfNotSuccess(() => NativeMethods.k4a_transformation_depth_image_to_point_cloud(
this.handle,
depthReference.DangerousGetHandle(),
camera,
pointCloudReference.DangerousGetHandle()));
// Copy the native memory back to managed memory if required
pointCloudReference.InvalidateMemory();
}
}
}
/// <summary>
/// Transforms a depth Image and a custom Image from the depth camera perspective to the color camera perspective.
/// </summary>
/// <param name="depth">Depth image to transform.</param>
/// <param name="custom">Custom image to transform.</param>
/// <param name="transformedDepth">An transformed depth image to hold the output.</param>
/// <param name="transformedCustom">An transformed custom image to hold the output.</param>
/// <param name="interpolationType">Parameter that controls how pixels in custom image should be interpolated when transformed to color camera space.</param>
/// <param name="invalidCustomValue">Defines the custom image pixel value that should be written to transformedCustom in case the corresponding depth pixel can not be transformed into the color camera space.</param>
/// <remarks>
/// The <paramref name="transformedDepth"/> Image must be of the resolution of the color camera, and
/// of the pixel format of the depth image.
/// The <paramref name="transformedCustom"/> Image must be of the resolution of the color camera, and
/// of the pixel format of the custom image.
/// </remarks>
public void DepthImageToColorCameraCustom(Image depth, Image custom, Image transformedDepth, Image transformedCustom, TransformationInterpolationType interpolationType, uint invalidCustomValue)
{
if (depth == null)
{
throw new ArgumentNullException(nameof(depth));
}
if (custom == null)
{
throw new ArgumentNullException(nameof(custom));
}
if (transformedDepth == null)
{
throw new ArgumentNullException(nameof(transformedDepth));
}
if (transformedCustom == null)
{
throw new ArgumentNullException(nameof(transformedCustom));
}
if (custom.Format != ImageFormat.Custom8 && custom.Format != ImageFormat.Custom16)
{
throw new NotSupportedException("Failed to support this format of custom image!");
}
if (transformedCustom.Format != ImageFormat.Custom8 && transformedCustom.Format != ImageFormat.Custom16)
{
throw new NotSupportedException("Failed to support this format of transformed custom image!");
}
if (custom.Format != transformedCustom.Format)
{
throw new NotSupportedException("Failed to support this different format of custom image and transformed custom image!!");
}
lock (this)
{
// Create a new reference to the Image objects so that they cannot be disposed while
// we are performing the transformation
using (Image depthReference = depth.Reference())
using (Image customReference = custom.Reference())
using (Image transformedDepthReference = transformedDepth.Reference())
using (Image transformedCustomReference = transformedCustom.Reference())
{
// Ensure changes made to the managed memory are visible to the native layer
depthReference.FlushMemory();
customReference.FlushMemory();
AzureKinectException.ThrowIfNotSuccess(() => NativeMethods.k4a_transformation_depth_image_to_color_camera_custom(
this.handle,
depthReference.DangerousGetHandle(),
customReference.DangerousGetHandle(),
transformedDepthReference.DangerousGetHandle(),
transformedCustom.DangerousGetHandle(),
interpolationType,
invalidCustomValue));
// Copy the native memory back to managed memory if required
transformedDepthReference.InvalidateMemory();
transformedCustom.InvalidateMemory();
}
}
}
