Пример #1
0
        public void Transform_MemoryToFile()
        {
            var jpeg   = File.ReadAllBytes(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "tu.jpg"));
            var output = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Path.GetRandomFileName());

            if (JpegTools.Transform(jpeg, output, false, true))
            {
                var res = File.ReadAllBytes(output);
                Assert.That(res.Length, Is.LessThan(jpeg.Length));
            }
            else
            {
                Assert.Fail();
            }
            Assert.IsTrue(IsJpegImage(output));
            File.Delete(output);
        }
Пример #2
0
        public void Transform_MemoryToMemory()
        {
            var jpeg = File.ReadAllBytes(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "tu.jpg"));

            if (JpegTools.Transform(jpeg, out byte[] res, copy: false, optimize: true))
Пример #3
0
        private async Task <IRandomAccessStream> ResizeStreamAsync(IRandomAccessStream stream, Size size, PhotoOrientation orientation)
        {
            var rotation = 0;

            switch (orientation)
            {
            case PhotoOrientation.Rotate180:
            {
                rotation = -180;
            };
                break;

            case PhotoOrientation.Rotate270:
            {
                rotation = -270;
            };
                break;

            case PhotoOrientation.Rotate90:
            {
                rotation = -90;
            };
                break;
            }

            using (var resizedStream = new InMemoryRandomAccessStream())
            {
                var buffer = new byte[stream.Size].AsBuffer();

                stream.Seek(0);

                await stream.ReadAsync(buffer, buffer.Length, InputStreamOptions.None);

                var resizeConfiguration = new AutoResizeConfiguration(
                    (uint)(size.Width * size.Height * 4 * 2), size,
                    new Size(0, 0), AutoResizeMode.Automatic, 0.7, ColorSpace.Yuv420);

                buffer = await JpegTools.AutoResizeAsync(buffer, resizeConfiguration);

                await resizedStream.WriteAsync(buffer);

                await resizedStream.FlushAsync();

                if (rotation != 0)
                {
                    resizedStream.Seek(0);

                    var filters = new List <IFilter>()
                    {
                        new RotationFilter(rotation)
                    };

                    using (var source = new RandomAccessStreamImageSource(resizedStream))
                        using (var effect = new FilterEffect(source)
                        {
                            Filters = filters
                        })
                            using (var renderer = new JpegRenderer(effect))
                            {
                                buffer = await renderer.RenderAsync();

                                using (var rotatedResizedStream = new InMemoryRandomAccessStream())
                                {
                                    await rotatedResizedStream.WriteAsync(buffer);

                                    await rotatedResizedStream.FlushAsync();

                                    return(rotatedResizedStream.CloneStream());
                                }
                            }
                }
                else
                {
                    return(resizedStream.CloneStream());
                }
            }
        }