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;
