< Summary - ReFlex - Library

Information
Class: Graphics.StreamDataConverter
Assembly: ReFlex.Core.Graphics
File(s): D:\a\reflex\reflex\library\src\Core\Graphics\StreamDataConverter.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 60
Coverable lines: 60
Total lines: 112
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 12
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
ConvertJpegToRawBytes(...)0%2040%
ConvertJpegToRawBytes(...)0%2040%
ConvertRawBytesToJpeg()0%2040%
ConvertRawBytesToJpeg()100%210%
DecodeImageData(...)100%210%
EncodeImageData(...)100%210%

File(s)

D:\a\reflex\reflex\library\src\Core\Graphics\StreamDataConverter.cs

#LineLine coverage
 1using System;
 2using System.IO;
 3using System.Runtime.CompilerServices;
 4using System.Text;
 5using System.Threading.Tasks;
 6using ReFlex.Core.Common.Components;
 7using ReFlex.Core.Common.Util;
 8using SixLabors.ImageSharp;
 9using SixLabors.ImageSharp.PixelFormats;
 10using SixLabors.ImageSharp.Processing;
 11
 12namespace Graphics
 13{
 14    public class StreamDataConverter
 15    {
 16        public static byte[] ConvertJpegToRawBytes(byte[] imageData, int targetWidth, int targetHeight, DepthImageFormat
 017        {
 018            switch (sourceFormat)
 19            {
 20                case DepthImageFormat.Greyccale48bpp:
 021                    return ConvertJpegToRawBytes<Rgb48>(imageData, targetWidth, targetHeight, convertBlackWhite);
 22                case DepthImageFormat.Greyscale8bpp:
 023                    return ConvertJpegToRawBytes<L8>(imageData, targetWidth, targetHeight, convertBlackWhite);
 24                case DepthImageFormat.Rgb24bpp:
 25                default:
 026                    return ConvertJpegToRawBytes<Rgb24>(imageData, targetWidth, targetHeight, convertBlackWhite);
 27            }
 028        }
 29
 30        public static byte[] ConvertJpegToRawBytes<T>(byte[] imageData, int targetWidth, int targetHeight, bool convertB
 031        {
 032            using (var ms1 = new MemoryStream(imageData))
 033            using (var image = Image.Load<T>(ms1))
 034            {
 035                var options = new ResizeOptions
 036                {
 037                    Mode = ResizeMode.Crop,
 038                    Size = new Size(targetWidth, targetHeight),
 039                    Position = AnchorPositionMode.TopLeft
 040                };
 041                image.Mutate(c => c.Resize(options));
 042                if (convertBlackWhite)
 043                    image.Mutate(c => c.BlackWhite());
 44
 045                var result = new byte[image.Width * image.Height * Unsafe.SizeOf<Rgba32>()];
 046                image.CopyPixelDataTo(result);
 47
 048                return result;
 49            }
 050        }
 51
 52        /// <summary>
 53        /// @TODO: check if more conversions are possible: https://docs.sixlabors.com/api/ImageSharp/SixLabors.ImageShar
 54        /// </summary>
 55        /// <param name="cameraData"></param>
 56        /// <returns></returns>
 57        public static async Task<byte[]> ConvertRawBytesToJpeg(ImageByteArray cameraData)
 058        {
 59
 060            switch (cameraData.Format)
 61            {
 62                case DepthImageFormat.Greyccale48bpp:
 063                    return await ConvertRawBytesToJpeg<Rgb48>(cameraData);
 64                case DepthImageFormat.Greyscale8bpp:
 065                    return await ConvertRawBytesToJpeg<L8>(cameraData);
 66                case DepthImageFormat.Rgb24bpp:
 67                default:
 068                    return await ConvertRawBytesToJpeg<Rgb24>(cameraData);
 69            }
 070        }
 71
 72        public static async Task<byte[]> ConvertRawBytesToJpeg<T>(ImageByteArray cameraData) where T: unmanaged, IPixel<
 073        {
 74            byte[] sendImage;
 75
 076            return await Task.Run(() =>
 077            {
 078
 079                using (var ms1 = new MemoryStream(cameraData.ImageData))
 080                {
 081                    using (var image = Image.LoadPixelData<T>(ms1.ToArray(), cameraData.Width, cameraData.Height))
 082                    using (var ms2 = new MemoryStream())
 083                    {
 084                        //var file = DepthImageFormatTools.GetFileExtension(cameraData.Format);
 085                        //if (file.EndsWith("png"))
 086                        //    image.SaveAsPng(ms2);
 087                        //else
 088                        image.SaveAsJpeg(ms2);
 089
 090                        sendImage = ms2.ToArray();
 091                    }
 092                }
 093
 094                return sendImage;
 095            });
 096        }
 97
 98        public static byte[] DecodeImageData(byte[] streamData, string prefixToRemove)
 099        {
 0100            var data = Encoding.UTF8.GetString(streamData);
 101
 0102            data = data.Replace(prefixToRemove, "");
 0103            return Convert.FromBase64String(data);
 0104        }
 105
 106        public static byte[] EncodeImageData(byte[] rawData, string prefix)
 0107        {
 0108            var base64StringResult = Convert.ToBase64String(rawData);
 0109            return Encoding.UTF8.GetBytes($"{prefix}{base64StringResult}");
 0110        }
 111    }
 112}