public ImageSize GetImageSize(string path) { using (var s = new SKFileStream(path)) { using (var codec = SKCodec.Create(s)) { var info = codec.Info; return(new ImageSize { Width = info.Width, Height = info.Height }); } } }
/// <inheritdoc /> /// <exception cref="ArgumentNullException">The path is null.</exception> /// <exception cref="FileNotFoundException">The path is not valid.</exception> /// <exception cref="SkiaCodecException">The file at the specified path could not be used to generate a codec.</exception> public ImageDimensions GetImageSize(string path) { if (!File.Exists(path)) { throw new FileNotFoundException("File not found", path); } using (var codec = SKCodec.Create(path, out SKCodecResult result)) { EnsureSuccess(result); var info = codec.Info; return(new ImageDimensions(info.Width, info.Height)); } }
public AnimatedGifPage() { InitializeComponent(); string resourceID = "SkiaSharpFormsDemos.Media.Newtons_cradle_animation_book_2.gif"; Assembly assembly = GetType().GetTypeInfo().Assembly; using (Stream stream = assembly.GetManifestResourceStream(resourceID)) using (SKManagedStream skStream = new SKManagedStream(stream)) using (SKCodec codec = SKCodec.Create(skStream)) { // Get frame count and allocate bitmaps int frameCount = codec.FrameCount; bitmaps = new SKBitmap[frameCount]; durations = new int[frameCount]; accumulatedDurations = new int[frameCount]; // Note: There's also a RepetitionCount property of SKCodec not used here // Loop through the frames for (int frame = 0; frame < frameCount; frame++) { // From the FrameInfo collection, get the duration of each frame durations[frame] = codec.FrameInfo[frame].Duration; // Create a full-color bitmap for each frame SKImageInfo imageInfo = new SKImageInfo(codec.Info.Width, codec.Info.Height); bitmaps[frame] = new SKBitmap(imageInfo); // Get the address of the pixels in that bitmap IntPtr pointer = bitmaps[frame].GetPixels(); // Create an SKCodecOptions value to specify the frame SKCodecOptions codecOptions = new SKCodecOptions(frame, false); // Copy pixels from the frame into the bitmap codec.GetPixels(imageInfo, pointer, codecOptions); } // Sum up the total duration for (int frame = 0; frame < durations.Length; frame++) { totalDuration += durations[frame]; } // Calculate the accumulated durations for (int frame = 0; frame < durations.Length; frame++) { accumulatedDurations[frame] = durations[frame] + (frame == 0 ? 0 : accumulatedDurations[frame - 1]); } } }
public unsafe void StreamThatHasLostOwnershipIsDisposed() { var bytes = File.ReadAllBytes(Path.Combine(PathToImages, "color-wheel.png")); var dotnet = new MemoryStream(bytes); var stream = new SKManagedStream(dotnet, true); var handle = stream.Handle; Assert.True(stream.OwnsHandle); Assert.True(SKObject.GetInstance <SKManagedStream>(handle, out _)); var codec = SKCodec.Create(stream); Assert.False(stream.OwnsHandle); codec.Dispose(); Assert.False(SKObject.GetInstance <SKManagedStream>(handle, out _)); }
public void BitmapDecodesCorrectly() { byte[] codecPixels; byte[] bitmapPixels; using (var codec = SKCodec.Create(new SKFileStream(Path.Combine(PathToImages, "baboon.png")))) { codecPixels = codec.Pixels; } using (var bitmap = SKBitmap.Decode(Path.Combine(PathToImages, "baboon.png"))) { bitmapPixels = bitmap.Bytes; } Assert.Equal(codecPixels, bitmapPixels); }
protected override void OnDrawSample(SKCanvas canvas, int width, int height) { canvas.Clear(SKColors.White); // load the embedded resource stream using (var stream = new SKManagedStream(SampleMedia.Images.ColorWheel)) using (var codec = SKCodec.Create(stream)) using (var paint = new SKPaint()) using (var tf = SKTypeface.FromFamilyName("Arial")) { var info = codec.Info; var encodedInfo = codec.EncodedInfo; paint.IsAntialias = true; paint.TextSize = 14; paint.Typeface = tf; paint.Color = SKColors.Black; // decode the image using (var bitmap = new SKBitmap(info.Width, info.Height, info.ColorType, info.IsOpaque ? SKAlphaType.Opaque : SKAlphaType.Premul)) { IntPtr length; var result = codec.GetPixels(bitmap.Info, bitmap.GetPixels(out length)); if (result == SKCodecResult.Success || result == SKCodecResult.IncompleteInput) { var x = 25; var y = 25; canvas.DrawBitmap(bitmap, x, y); x += bitmap.Info.Width + 25; y += 14; canvas.DrawText(string.Format("Result: {0}", result), x, y, paint); y += 20; canvas.DrawText(string.Format("Size: {0}px x {1}px", bitmap.Width, bitmap.Height), x, y, paint); y += 20; canvas.DrawText(string.Format("Pixels: {0} @ {1}b/px", bitmap.Pixels.Length, bitmap.BytesPerPixel), x, y, paint); y += 20; canvas.DrawText(string.Format("Encoding: {0} ({1}) @ {2}-bit color", encodedInfo.Color, encodedInfo.Alpha, encodedInfo.BitsPerComponent), x, y, paint); } } } }
public void BitmapDecodesCorrectlyWithManagedStream() { byte[] codecPixels; byte[] bitmapPixels; var stream = File.OpenRead(Path.Combine(PathToImages, "baboon.png")); using (var codec = SKCodec.Create(new SKManagedStream(stream))) { codecPixels = codec.Pixels; } using (var bitmap = SKBitmap.Decode(Path.Combine(PathToImages, "baboon.png"))) { bitmapPixels = bitmap.Bytes; } Assert.Equal(codecPixels, bitmapPixels); }
private SKBitmap GetChildViewImage() { var r = DependencyService.Get <IViewImageProvider>(DependencyFetchTarget.GlobalInstance).GetViewImage(ChildView); SKCodec codec = SKCodec.Create(new MemoryStream(r)); return(SKBitmap.Decode(codec)); //string resourceID = "FormsRevealer.Sample.ape.jpg"; //Assembly assembly = GetType().GetTypeInfo().Assembly; //SKBitmap resourceBitmap; //using (Stream stream = assembly.GetManifestResourceStream(resourceID)) //{ // resourceBitmap = SKBitmap.Decode(stream); //} //return resourceBitmap; }
private SKBitmap LoadBitmap(Stream stream, out SKEncodedOrigin origin) { using var managedStream = new SKManagedStream(stream); using var codec = SKCodec.Create(managedStream); origin = codec.EncodedOrigin; var info = codec.Info; var bitmap = new SKBitmap(info.Width, info.Height, SKImageInfo.PlatformColorType, info.IsOpaque ? SKAlphaType.Opaque : SKAlphaType.Premul); var result = codec.GetPixels(bitmap.Info, bitmap.GetPixels(out _)); if (result == SKCodecResult.Success || result == SKCodecResult.IncompleteInput) { return(bitmap); } throw new ArgumentException("Невозможно загрузить изображение из источника."); }
private static TwitchEmote GetTwitchEmote(string fileName, string url, string name, string imageType, string id, int imageScale) { try { using (WebClient client = new WebClient()) { SKBitmap emoteBitmap = null; byte[] bytes = null; bool fileExists = File.Exists(fileName); if (fileExists) { //File may already be locked, can just download again from URL try { bytes = File.ReadAllBytes(fileName); } catch { } emoteBitmap = SKBitmap.Decode(bytes); } if (!fileExists || emoteBitmap == null) { bytes = client.DownloadData(url); try { //File may already be open, just a cache so can ignore File.WriteAllBytes(fileName, bytes); } catch { } emoteBitmap = SKBitmap.Decode(bytes); } MemoryStream ms = new MemoryStream(bytes); return(new TwitchEmote(new List <SKBitmap>() { emoteBitmap }, SKCodec.Create(ms), name, imageType, id, imageScale, bytes)); } } catch { return(null); } }
private void LoadPng(Item item) { try { if (!File.Exists(item.ReferencePngPath)) { return; } using var codec = SKCodec.Create(new SKFileStream(item.ReferencePngPath)); #if USE_COLORSPACE var skImageInfo = new SKImageInfo(codec.Info.Width, codec.Info.Height, SKSvg.s_colorType, SKSvg.s_alphaType, SvgPaintingExtensions.Srgb); #else var skImageInfo = new SKImageInfo(codec.Info.Width, codec.Info.Height, SKSvg.s_colorType, SKSvg.s_alphaType); #endif var skReferenceBitmap = new SKBitmap(skImageInfo); codec.GetPixels(skReferenceBitmap.Info, skReferenceBitmap.GetPixels()); if (skReferenceBitmap == null) { return; } item.ReferencePng = skReferenceBitmap; float scaleX = skReferenceBitmap.Width / item.Picture.CullRect.Width; float scaleY = skReferenceBitmap.Height / item.Picture.CullRect.Height; #if USE_COLORSPACE using var svgBitmap = item.Picture.ToBitmap(SKColors.Transparent, scaleX, scaleY, SKSvg.s_colorType, SKSvg.s_alphaType, SvgPaintingExtensions.Srgb); #else using var svgBitmap = item.Picture.ToBitmap(SKColors.Transparent, scaleX, scaleY, SKSvg.s_colorType, SKSvg.s_alphaType); #endif if (svgBitmap.Width == skReferenceBitmap.Width && svgBitmap.Height == skReferenceBitmap.Height) { var pixelDiff = PixelDiff(skReferenceBitmap, svgBitmap); item.PixelDiff = pixelDiff; } } catch (Exception ex) { Debug.WriteLine($"Failed to load reference png: {item.ReferencePngPath}"); Debug.WriteLine(ex.Message); Debug.WriteLine(ex.StackTrace); } }
private SKBitmap LoadBitmap(Stream stream, out SKEncodedOrigin origin) { using SKManagedStream s = new SKManagedStream(stream); using SKCodec codec = SKCodec.Create(s); origin = codec.EncodedOrigin; SKImageInfo info = codec.Info; SKBitmap bitmap = new SKBitmap(info.Width, info.Height, SKImageInfo.PlatformColorType, info.IsOpaque ? SKAlphaType.Opaque : SKAlphaType.Premul); SKCodecResult result = codec.GetPixels(bitmap.Info, bitmap.GetPixels(out IntPtr length)); if (result == SKCodecResult.Success || result == SKCodecResult.IncompleteInput) { return(bitmap); } else { throw new ArgumentException("Unable to load bitmap from provided data"); } }
public unsafe void StreamLosesOwnershipToCodecButIsNotForgotten() { var bytes = File.ReadAllBytes(Path.Combine(PathToImages, "color-wheel.png")); var stream = new SKMemoryStream(bytes); var handle = stream.Handle; Assert.True(stream.OwnsHandle); Assert.True(SKObject.GetInstance <SKMemoryStream>(handle, out _)); var codec = SKCodec.Create(stream); Assert.False(stream.OwnsHandle); stream.Dispose(); Assert.True(SKObject.GetInstance <SKMemoryStream>(handle, out _)); Assert.Equal(SKCodecResult.Success, codec.GetPixels(out var pixels)); Assert.NotEmpty(pixels); }
/// <summary> /// Encodes the BlurHash representation of the image. /// </summary> /// <param name="xComponent">The number x components.</param> /// <param name="yComponent">The number y components.</param> /// <param name="filename">The path to an encoded image on the file system.</param> /// <returns>BlurHash representation of the image.</returns> public static string Encode(int xComponent, int yComponent, string filename) { using (SKCodec codec = SKCodec.Create(filename)) { var newInfo = new SKImageInfo() { Width = codec.Info.Width, Height = codec.Info.Height, ColorType = SKColorType.Rgba8888, AlphaType = SKAlphaType.Unpremul, ColorSpace = SKColorSpace.CreateSrgb() }; using (SKBitmap bitmap = SKBitmap.Decode(codec, newInfo)) { return(EncodeInternal(xComponent, yComponent, bitmap)); } } }
public WriteableBitmapImpl(Stream stream, int decodeSize, bool horizontal, BitmapInterpolationMode interpolationMode) { using (var skStream = new SKManagedStream(stream)) using (var skData = SKData.Create(skStream)) using (var codec = SKCodec.Create(skData)) { var info = codec.Info; // get the scale that is nearest to what we want (eg: jpg returned 512) var supportedScale = codec.GetScaledDimensions(horizontal ? ((float)decodeSize / info.Width) : ((float)decodeSize / info.Height)); // decode the bitmap at the nearest size var nearest = new SKImageInfo(supportedScale.Width, supportedScale.Height); var bmp = SKBitmap.Decode(codec, nearest); // now scale that to the size that we want var realScale = horizontal ? ((double)info.Height / info.Width) : ((double)info.Width / info.Height); SKImageInfo desired; if (horizontal) { desired = new SKImageInfo(decodeSize, (int)(realScale * decodeSize)); } else { desired = new SKImageInfo((int)(realScale * decodeSize), decodeSize); } if (bmp.Width != desired.Width || bmp.Height != desired.Height) { var scaledBmp = bmp.Resize(desired, interpolationMode.ToSKFilterQuality()); bmp.Dispose(); bmp = scaledBmp; } _bitmap = bmp; PixelSize = new PixelSize(bmp.Width, bmp.Height); Dpi = SkiaPlatform.DefaultDpi; } }
public void GetGifFrames() { const int FrameCount = 16; var stream = new SKFileStream(Path.Combine(PathToImages, "animated-heart.gif")); using (var codec = SKCodec.Create(stream)) { Assert.Equal(-1, codec.RepetitionCount); var frameInfos = codec.FrameInfo; Assert.Equal(FrameCount, frameInfos.Length); Assert.Equal(-1, frameInfos [0].RequiredFrame); var cachedFrames = new SKBitmap [FrameCount]; var info = new SKImageInfo(codec.Info.Width, codec.Info.Height); var decode = new Action <SKBitmap, bool, int> ((bm, cached, index) => { if (cached) { var requiredFrame = frameInfos [index].RequiredFrame; if (requiredFrame != -1) { Assert.True(cachedFrames [requiredFrame].CopyTo(bm)); } } var opts = new SKCodecOptions(index, cached); var result = codec.GetPixels(info, bm.GetPixels(), opts); Assert.Equal(SKCodecResult.Success, result); }); for (var i = 0; i < FrameCount; i++) { var cachedFrame = cachedFrames [i] = new SKBitmap(info); decode(cachedFrame, true, i); var uncachedFrame = new SKBitmap(info); decode(uncachedFrame, false, i); Assert.Equal(cachedFrame.Bytes, uncachedFrame.Bytes); } } }
public void CanCreateStreamCodec() { var stream = new SKFileStream(Path.Combine(PathToImages, "color-wheel.png")); using (var codec = SKCodec.Create(stream)) { Assert.AreEqual(SKEncodedFormat.Png, codec.EncodedFormat); Assert.AreEqual(128, codec.Info.Width); Assert.AreEqual(128, codec.Info.Height); Assert.AreEqual(SKAlphaType.Unpremul, codec.Info.AlphaType); if (IsUnix) { Assert.AreEqual(SKColorType.Rgba8888, codec.Info.ColorType); } else { Assert.AreEqual(SKColorType.Bgra8888, codec.Info.ColorType); } } }
public IImage LoadImageFromStream(Stream stream, ImageFormat formatHint = ImageFormat.Png) { using (var s = new SKManagedStream(stream)) { using (var codec = SKCodec.Create(s)) { var info = codec.Info; var bitmap = new SKBitmap(info.Width, info.Height, info.ColorType, info.IsOpaque ? SKAlphaType.Opaque : SKAlphaType.Premul); var result = codec.GetPixels(bitmap.Info, bitmap.GetPixels(out _)); if (result == SKCodecResult.Success || result == SKCodecResult.IncompleteInput) { return(new SkiaImage(bitmap)); } } } return(null); }
/// <summary> /// Resizes the image and encodes the BlurHash representation of the image. /// </summary> /// <param name="xComponent">The number x components.</param> /// <param name="yComponent">The number y components.</param> /// <param name="filename">The path to an encoded image on the file system.</param> /// <param name="maxWidth">The maximum width to resize the image to.</param> /// <param name="maxHeight">The maximum height to resize the image to.</param> /// <returns>BlurHash representation of the image.</returns> public static string Encode(int xComponent, int yComponent, string filename, int maxWidth, int maxHeight) { using (SKCodec codec = SKCodec.Create(filename)) { var width = codec.Info.Width; var height = codec.Info.Height; float scaleFactor = 0; if (width > maxWidth || height > maxHeight) { scaleFactor = ScaleHelper.GetScale(width, height, maxWidth, maxHeight); SKSizeI supportedScale = codec.GetScaledDimensions(scaleFactor); width = supportedScale.Width; height = supportedScale.Height; } var newInfo = new SKImageInfo() { Width = width, Height = height, ColorType = SKColorType.Rgba8888, AlphaType = SKAlphaType.Unpremul, ColorSpace = SKColorSpace.CreateSrgb() }; using (SKBitmap bitmap = SKBitmap.Decode(codec, newInfo)) { if (scaleFactor == 0) { return(EncodeInternal(xComponent, yComponent, bitmap)); } var(scaledWidth, scaledHeight) = ScaleHelper.GetScaleDimensions(bitmap.Width, bitmap.Height, scaleFactor); newInfo = newInfo.WithSize(scaledWidth, scaledHeight); using (SKBitmap scaledBitmap = bitmap.Resize(newInfo, SKFilterQuality.Low)) { return(EncodeInternal(xComponent, yComponent, scaledBitmap)); } } } }
public unsafe void StreamLosesOwnershipAndCanBeGarbageCollected() { VerifyImmediateFinalizers(); var bytes = File.ReadAllBytes(Path.Combine(PathToImages, "color-wheel.png")); DoWork(out var codecH, out var streamH); CollectGarbage(); Assert.False(SKObject.GetInstance <SKMemoryStream>(streamH, out _)); Assert.False(SKObject.GetInstance <SKCodec>(codecH, out _)); void DoWork(out IntPtr codecHandle, out IntPtr streamHandle) { var codec = CreateCodec(out streamHandle); codecHandle = codec.Handle; CollectGarbage(); Assert.Equal(SKCodecResult.Success, codec.GetPixels(out var pixels)); Assert.NotEmpty(pixels); Assert.True(SKObject.GetInstance <SKMemoryStream>(streamHandle, out var stream)); Assert.False(stream.OwnsHandle); Assert.True(stream.IgnorePublicDispose); } SKCodec CreateCodec(out IntPtr streamHandle) { var stream = new SKMemoryStream(bytes); streamHandle = stream.Handle; Assert.True(stream.OwnsHandle); Assert.False(stream.IgnorePublicDispose); Assert.True(SKObject.GetInstance <SKMemoryStream>(streamHandle, out _)); return(SKCodec.Create(stream)); } }
public async Task Init(Stream sourceStream) { if (Image != null) { return; } FileStream = sourceStream; var reading = Task.Run(() => { var data = SKData.Create(sourceStream); var image = SKImage.FromEncodedData(data); var bitmap = SKBitmap.FromImage(image); var codec = SKCodec.Create(data); SKEncodedImageFormat imgFormat = codec.EncodedFormat; SKImageInfo info = codec.Info; return(image, bitmap, info, imgFormat); }); (Image, Bitmap, Info, Format) = await reading; }
public void EncodeWithSimpleSerializer() { var bitmap = CreateTestBitmap(); bool encoded = false; var serializer = SKPixelSerializer.Create(pixmap => { encoded = true; return(pixmap.Encode(SKEncodedImageFormat.Jpeg, 100)); }); var image = SKImage.FromBitmap(bitmap); var data = image.Encode(serializer); var codec = SKCodec.Create(data); Assert.Equal(SKEncodedImageFormat.Jpeg, codec.EncodedFormat); Assert.True(encoded); }
protected override async Task OnInit() { await base.OnInit(); var stream = new SKManagedStream(SampleMedia.Images.AnimatedHeartGif, true); codec = SKCodec.Create(stream); frames = codec.FrameInfo; info = codec.Info; info = new SKImageInfo(info.Width, info.Height, SKImageInfo.PlatformColorType, SKAlphaType.Premul); bitmap = new SKBitmap(info); cts = new CancellationTokenSource(); scheduler = TaskScheduler.FromCurrentSynchronizationContext(); var loop = Task.Run(async() => { while (!cts.IsCancellationRequested) { var duration = frames[currentFrame].Duration; if (duration <= 0) { duration = 100; } await Task.Delay(duration, cts.Token); // next frame currentFrame++; if (currentFrame >= frames.Length) { currentFrame = 0; } new Task(Refresh).Start(scheduler); } }, cts.Token); }
/// <summary> /// Loads an image from a disk file, decoding for the optimal required /// size so that we don't load the entire image for a smaller target, /// and auto-orienting the bitmap according to the codec origin. /// This is faster than the slow method above, because it uses the trick /// outlined here: /// https://forums.xamarin.com/discussion/88794/fast-way-to-decode-skbitmap-from-byte-jpeg-raw /// </summary> /// <param name="source"></param> /// <param name="desiredWidth"></param> /// <returns></returns> private SKBitmap LoadOrientedBitmap(FileInfo source, int desiredWidth) { Stopwatch load = new Stopwatch("SkiaSharpLoad"); SKCodec codec = SKCodec.Create(source.FullName); SKImageInfo info = codec.Info; // get the scale that is nearest to what we want (eg: jpg returned 512) SKSizeI supportedScale = codec.GetScaledDimensions((float)desiredWidth / info.Width); // decode the bitmap at the nearest size SKImageInfo nearest = new SKImageInfo(supportedScale.Width, supportedScale.Height); SKBitmap bmp = SKBitmap.Decode(codec, nearest); load.Stop(); // First, auto-orient the bitmap var sourceBitmap = AutoOrient(bmp, codec.EncodedOrigin); return(sourceBitmap); }
public ImageSize GetImageSize(string path) { if (!_fileSystem.FileExists(path)) { throw new FileNotFoundException("File not found", path); } using (var s = new SKFileStream(NormalizePath(path, _fileSystem))) { using (var codec = SKCodec.Create(s)) { var info = codec.Info; return(new ImageSize { Width = info.Width, Height = info.Height }); } } }
internal static SKBitmap Decode(string path, bool forceCleanBitmap, out SKCodecOrigin origin) { var requiresTransparencyHack = TransparentImageTypes.Contains(Path.GetExtension(path) ?? string.Empty); if (requiresTransparencyHack || forceCleanBitmap) { using (var stream = new SKFileStream(path)) { var codec = SKCodec.Create(stream); // create the bitmap var bitmap = new SKBitmap(codec.Info.Width, codec.Info.Height, !requiresTransparencyHack); // decode codec.GetPixels(bitmap.Info, bitmap.GetPixels()); origin = codec.Origin; return(bitmap); } } var resultBitmap = SKBitmap.Decode(path); if (resultBitmap == null) { return(Decode(path, true, out origin)); } // If we have to resize these they often end up distorted if (resultBitmap.ColorType == SKColorType.Gray8) { using (resultBitmap) { return(Decode(path, true, out origin)); } } origin = SKCodecOrigin.TopLeft; return(resultBitmap); }
public IBitmapImpl LoadBitmap(System.IO.Stream stream) { using (var s = new SKManagedStream(stream)) { using (var codec = SKCodec.Create(s)) { var info = codec.Info; var bitmap = new SKBitmap(info.Width, info.Height, SKImageInfo.PlatformColorType, info.IsOpaque ? SKAlphaType.Opaque : SKAlphaType.Premul); IntPtr length; var result = codec.GetPixels(bitmap.Info, bitmap.GetPixels(out length)); if (result == SKCodecResult.Success || result == SKCodecResult.IncompleteInput) { return(new BitmapImpl(bitmap)); } else { throw new ArgumentException("Unable to load bitmap from provided data"); } } } }
public unsafe void ReleaseDataWasInvokedOnlyAfterTheCodecWasFinished() { var path = Path.Combine(PathToImages, "color-wheel.png"); var bytes = File.ReadAllBytes(path); var released = false; fixed(byte *b = bytes) { var data = SKData.Create((IntPtr)b, bytes.Length, (addr, ctx) => released = true); var codec = SKCodec.Create(data); Assert.NotEqual(SKImageInfo.Empty, codec.Info); data.Dispose(); Assert.False(released, "The SKDataReleaseDelegate was called too soon."); codec.Dispose(); Assert.True(released, "The SKDataReleaseDelegate was not called at all."); } }
//creates scaled down versions of the image and saves them on disk public void CreateThumbnails(Stream imageStream, string filePath) { //folder for thumbnails string dir = Path.Combine(Path.GetDirectoryName(filePath), "thumbnails"); Directory.CreateDirectory(dir); //file name without extensions string displayName = Path.GetFileNameWithoutExtension(filePath); //file extensions string ext = Path.GetExtension(filePath); var format = GetFormat(filePath); using (var inputStream = new SKManagedStream(imageStream)) using (var codec = SKCodec.Create(inputStream)) using (var original = SKBitmap.Decode(codec)) using (var image = HandleOrientation(original, codec.Origin)) { foreach (ImageType type in Enum.GetValues(typeof(ImageType))) { int width = (int)type; int height = (int)Math.Round(width * ((float)image.Height / image.Width)); string thumbnailPath = Path.Combine(dir, $"{displayName}-{width}x{height}{ext}"); var info = new SKImageInfo(width, height); using (var resized = image.Resize(info, SKBitmapResizeMethod.Lanczos3)) using (var thumb = SKImage.FromBitmap(resized)) using (var fs = new FileStream(thumbnailPath, FileMode.CreateNew, FileAccess.ReadWrite)) { thumb.Encode(format, Quality) .SaveTo(fs); } } } }
public async Task PixelateSingleImage(string imagePath, string outputPath) { _imagePath = imagePath; if (File.Exists(outputPath)) { File.Delete(outputPath); } var outputDirectory = new FileInfo(outputPath).Directory; if (outputDirectory != null && !outputDirectory.Exists) { outputDirectory.Create(); } var bitmap = SKBitmap.Decode(imagePath); var origin = SKCodec.Create(imagePath).EncodedOrigin; var output = await Pixelate(bitmap, origin, _cloudConnector.AnalyseImage(imagePath)); await using var fileStream = File.Create(outputPath); await output.CopyToAsync(fileStream); }