/// <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(); } } }