public void TestPoint() { var defaultPoint = new TiffPoint(); Assert.Equal(0, defaultPoint.X); Assert.Equal(0, defaultPoint.Y); var point1 = new TiffPoint(1, 2); Assert.Equal(1, point1.X); Assert.Equal(2, point1.Y); Assert.False(point1.Equals(defaultPoint)); Assert.False(defaultPoint.Equals(point1)); Assert.False(point1 == defaultPoint); Assert.False(defaultPoint == point1); Assert.True(point1 != defaultPoint); Assert.True(defaultPoint != point1); Assert.False(point1.GetHashCode() == defaultPoint.GetHashCode()); var point2 = new TiffPoint(1, 2); Assert.True(point1.Equals(point2)); Assert.True(point2.Equals(point1)); Assert.True(point1 == point2); Assert.True(point2 == point1); Assert.False(point1 != point2); Assert.False(point2 != point1); Assert.True(point1.GetHashCode() == point2.GetHashCode()); }
/// <inheritdoc /> public override void Decode <TPixel>(TiffPoint offset, TiffSize readSize, TiffPoint destinationOffset, ITiffPixelBufferWriter <TPixel> writer) { if (writer is null) { throw new ArgumentNullException(nameof(writer)); } readSize = new TiffSize(Math.Max(0, Math.Min(writer.Width - destinationOffset.X, readSize.Width)), Math.Max(0, Math.Min(writer.Height - destinationOffset.Y, readSize.Height))); readSize = new TiffSize(Math.Max(0, Math.Min(Width - offset.X, readSize.Width)), Math.Max(0, Math.Min(Height - offset.Y, readSize.Height))); if (readSize.IsAreaEmpty) { return; } if (_parameters.ContentSource is null) { throw new InvalidOperationException("Failed to acquire ContentSource."); } using TiffFileContentReader reader = TiffSyncFileContentSource.WrapReader(_parameters.ContentSource.OpenReader()); var context = new TiffDefaultImageDecoderContext <TPixel>() { MemoryPool = _parameters.MemoryPool ?? MemoryPool <byte> .Shared, CancellationToken = CancellationToken.None, OperationContext = _parameters.OperationContext, ContentReader = reader, SourceImageSize = _parameters.ImageSize, SourceReadOffset = offset, ReadSize = readSize, PixelConverterFactory = _parameters.PixelConverterFactory ?? TiffDefaultPixelConverterFactory.Instance, DestinationWriter = new TiffPixelBufferWriter <TPixel>(TiffNoopDisposablePixelBufferWriter.Wrap(writer)).Crop(destinationOffset, readSize) }; _pipeline.RunAsync(context).AsTask().GetAwaiter().GetResult(); }
public ValueTask ReadAsync(TiffPoint offset, TiffPixelBufferWriter <TTiffPixel> destination, CancellationToken cancellationToken) { ITiffPixelBufferWriter <TTiffPixel> destinationWriter = TiffPixelBufferUnsafeMarshal.GetBuffer(destination, out TiffPoint destinationOffset, out TiffSize size); TiffPixelBufferWriter <TImageSharpPixel> newDestination = new ImageSharpConversionPixelBufferWriter <TImageSharpPixel, TIntermediate, TTiffPixel>(destinationWriter).AsPixelBufferWriter().Crop(destinationOffset, size); return(_source.ReadAsync(offset, newDestination, cancellationToken)); }
public ValueTask ReadAsync(TiffPoint offset, TiffPixelBufferWriter <TDestination> destination, CancellationToken cancellationToken) { ITiffPixelBufferWriter <TDestination> destinationWriter = TiffPixelBufferUnsafeMarshal.GetBuffer(destination, out TiffPoint destinationOffset, out TiffSize size); TiffPixelBufferWriter <TSource> newDestination = new TiffPassthroughPixelBufferWriter <TSource, TDestination>(destinationWriter).AsPixelBufferWriter().Crop(destinationOffset, size); return(_source.ReadAsync(offset, newDestination, cancellationToken)); }
public ImageSharpPixelBufferReader(ImageFrame <TPixel> image) { if (image is null) { throw new ArgumentNullException(nameof(image)); } _image = image; _offset = default; _size = new TiffSize(image.Width, image.Height); }
public void SetCropSize(TiffPoint offset, TiffSize originalReadSize) { CropOffset = offset; int copySizeX = Math.Max(0, Math.Min(SourceImageSize.Width - SourceReadOffset.X, ReadSize.Width)); int copySizeY = Math.Max(0, Math.Min(SourceImageSize.Height - SourceReadOffset.Y, ReadSize.Height)); copySizeX = Math.Max(0, Math.Min(originalReadSize.Width - offset.X, copySizeX)); copySizeY = Math.Max(0, Math.Min(originalReadSize.Height - offset.Y, copySizeY)); ReadSize = new TiffSize(copySizeX, copySizeY); }
public ValueTask ReadAsync(TiffPoint offset, TiffPixelBufferWriter <TPixel> destination, CancellationToken cancellationToken) { if (_flipLeftRight) { offset = new TiffPoint(Width - offset.X - destination.Width, offset.Y); } if (_flipTopBottom) { offset = new TiffPoint(offset.X, Height - offset.Y - destination.Height); } destination = new TiffFlippedPixelBufferWriter <TPixel>(destination, _flipLeftRight, _flipTopBottom).AsPixelBufferWriter(); return(_reader.ReadAsync(offset, destination, cancellationToken)); }
public override Task EncodeAsync(TiffImageFileDirectoryWriter writer, TiffPoint offset, TiffSize size, ITiffPixelBufferReader <TExposedPixel> reader, CancellationToken cancellationToken = default) { if (writer is null) { throw new ArgumentNullException(nameof(writer)); } if (reader is null) { throw new ArgumentNullException(nameof(reader)); } if (typeof(TExposedPixel) == typeof(TIntermediate)) { return(_encoder.EncodeAsync(writer, offset, size, new TiffPassthroughPixelBufferReader <TExposedPixel, TTiffPixel>(reader), cancellationToken)); } return(_encoder.EncodeAsync(writer, offset, size, new ImageSharpConversionPixelBufferReader <TExposedPixel, TIntermediate, TTiffPixel>(reader), cancellationToken)); }
/// <inheritdoc /> public override async Task DecodeAsync <TPixel>(TiffPoint offset, TiffSize readSize, TiffPoint destinationOffset, ITiffPixelBufferWriter <TPixel> writer, CancellationToken cancellationToken = default) { if (writer is null) { throw new ArgumentNullException(nameof(writer)); } readSize = new TiffSize(Math.Max(0, Math.Min(writer.Width - destinationOffset.X, readSize.Width)), Math.Max(0, Math.Min(writer.Height - destinationOffset.Y, readSize.Height))); readSize = new TiffSize(Math.Max(0, Math.Min(Width - offset.X, readSize.Width)), Math.Max(0, Math.Min(Height - offset.Y, readSize.Height))); if (readSize.IsAreaEmpty) { return; } if (_parameters.ContentSource is null) { throw new InvalidOperationException("Failed to acquire ContentSource."); } TiffFileContentReader reader = await _parameters.ContentSource.OpenReaderAsync(cancellationToken).ConfigureAwait(false); try { var context = new TiffDefaultImageDecoderContext <TPixel>() { MemoryPool = _parameters.MemoryPool ?? MemoryPool <byte> .Shared, CancellationToken = cancellationToken, OperationContext = _parameters.OperationContext, ContentReader = reader, SourceImageSize = _parameters.ImageSize, SourceReadOffset = offset, ReadSize = readSize, PixelConverterFactory = _parameters.PixelConverterFactory ?? TiffDefaultPixelConverterFactory.Instance, DestinationWriter = new TiffPixelBufferWriter <TPixel>(TiffNoopDisposablePixelBufferWriter.Wrap(writer)).Crop(destinationOffset, readSize) }; await _pipeline.RunAsync(context).ConfigureAwait(false); } finally { await reader.DisposeAsync().ConfigureAwait(false); } }
/// <inheritdoc /> public ValueTask ReadAsync(TiffPoint offset, TiffPixelBufferWriter <TPixel> destination, CancellationToken cancellationToken) { if (offset.X >= (uint)_size.Width || offset.Y >= (uint)_size.Height) { throw new ArgumentOutOfRangeException(nameof(offset)); } int width = Math.Min(_size.Width - offset.X, destination.Width); int height = Math.Min(_size.Height - offset.Y, destination.Height); ReadOnlySpan <TPixel> buffer = _buffer.GetReadOnlySpan(); int bufferWidth = _size.Width; for (int row = 0; row < height; row++) { ReadOnlySpan <TPixel> sourceSpan = buffer.Slice(bufferWidth * (offset.Y + row) + offset.X, width); using TiffPixelSpanHandle <TPixel> destinationHandle = destination.GetRowSpan(row); sourceSpan.CopyTo(destinationHandle.GetSpan()); } return(default);
public ValueTask ReadAsync(TiffPoint offset, TiffPixelBufferWriter <TPixel> destination, CancellationToken cancellationToken) { if (offset.X >= (uint)_size.Width || offset.Y >= (uint)_size.Height) { throw new ArgumentOutOfRangeException(nameof(offset)); } ImageFrame <TPixel> image = _image; int offsetX = _offset.X + offset.X; int offsetY = _offset.Y + offset.Y; int width = Math.Min(_size.Width - offset.X, destination.Width); int height = Math.Min(_size.Height - offset.Y, destination.Height); for (int row = 0; row < height; row++) { Span <TPixel> sourceSpan = image.GetPixelRowSpan(offsetY + row).Slice(offsetX, width); using TiffPixelSpanHandle <TPixel> destinationHandle = destination.GetRowSpan(row); sourceSpan.CopyTo(destinationHandle.GetSpan()); } return(default);
public ImageSharpPixelBufferReader(ImageFrame <TPixel> image, TiffPoint offset, TiffSize size) { if (image is null) { throw new ArgumentNullException(nameof(image)); } if (offset.X < 0) { size = new TiffSize(size.Width + offset.X, size.Height); offset = new TiffPoint(0, offset.Y); } if (offset.Y < 0) { size = new TiffSize(size.Width, size.Height + offset.Y); offset = new TiffPoint(offset.X, 0); } _image = image; _offset = offset; _size = new TiffSize(MathHelper.Clamp(size.Width, 0, image.Width), MathHelper.Clamp(size.Height, 0, image.Height)); }
/// <inheritdoc /> public override async Task EncodeAsync(TiffImageFileDirectoryWriter writer, TiffPoint offset, TiffSize size, ITiffPixelBufferReader <TPixel> reader, CancellationToken cancellationToken) { if (writer is null) { throw new ArgumentNullException(nameof(writer)); } if (reader is null) { throw new ArgumentNullException(nameof(reader)); } if (_ifdEncoder is null) { throw new InvalidOperationException("Ifd encoder is not configured."); } TiffPixelBufferReader <TPixel> structReader = reader.AsPixelBufferReader(); size = new TiffSize(Math.Max(0, Math.Min(structReader.Width - offset.X, structReader.Width)), Math.Max(0, Math.Min(structReader.Height - offset.Y, structReader.Height))); if (size.IsAreaEmpty) { throw new ArgumentOutOfRangeException(nameof(size), "The image size is zero."); } var context = new TiffDefaultImageEncoderContext <TPixel> { MemoryPool = _memoryPool ?? MemoryPool <byte> .Shared, CancellationToken = cancellationToken, FileWriter = writer.FileWriter, IfdWriter = writer, ImageSize = size, PixelConverterFactory = TiffDefaultPixelConverterFactory.Instance, PixelBufferReader = structReader }; await _ifdEncoder.RunAsync(context).ConfigureAwait(false); }
public ValueTask ReadAsync(TiffPoint offset, TiffPixelBufferWriter <TPixel> destination, CancellationToken cancellationToken) => default;