public async Task TestRoundtrip(bool isTile)
{
TiffGray8[] refImage = new TiffGray8[2048 * 2048];
TiffGray8[] testImage = new TiffGray8[2048 * 2048];
var rand = new Random(42);
rand.NextBytes(MemoryMarshal.AsBytes(refImage.AsSpan()));
var builder = new TiffImageEncoderBuilder();
builder.PhotometricInterpretation = TiffPhotometricInterpretation.BlackIsZero;
builder.Compression = TiffCompression.NoCompression;
builder.IsTiled = isTile;
// Make sure we have at least CacheSize strips or tiles
// Cache size in the current implementation is 256
// Any value greater than 256 should be OK.
builder.RowsPerStrip = 2; // 1024 strips
builder.TileSize = new TiffSize(16, 16); // 16384 tiles
var ms = new MemoryStream();
await GenerateImageAsync(ms, builder, TiffPixelBuffer.WrapReadOnly(refImage, 2048, 2048));
ms.Seek(0, SeekOrigin.Begin);
await using TiffFileReader tiff = await TiffFileReader.OpenAsync(ms, leaveOpen : true);
TiffImageDecoder decoder = await tiff.CreateImageDecoderAsync();
await decoder.DecodeAsync(TiffPixelBuffer.Wrap(testImage, 2048, 2048));
Assert.True(refImage.AsSpan().SequenceEqual(testImage.AsSpan()));
}
private Task EncodeImageAsync <TPixel>(ImageFrame <TPixel> image, TiffImageFileDirectoryWriter ifdWriter, CancellationToken cancellationToken) where TPixel : unmanaged, IPixel <TPixel>
{
ITiffEncoderOptions options = _options;
var builder = new TiffImageEncoderBuilder();
builder.MemoryPool = _memoryPool;
builder.PhotometricInterpretation = options.PhotometricInterpretation;
builder.Compression = options.Compression;
builder.IsTiled = options.IsTiled;
builder.RowsPerStrip = options.RowsPerStrip;
builder.TileSize = new TiffSize(options.TileSize.Width, options.TileSize.Height);
builder.Predictor = options.Predictor;
builder.EnableTransparencyForRgb = options.EnableTransparencyForRgb;
builder.Orientation = options.Orientation;
builder.DeflateCompressionLevel = options.DeflateCompressionLevel;
builder.JpegOptions = new TiffJpegEncodingOptions {
Quality = options.JpegQuality, OptimizeCoding = options.JpegOptimizeCoding
};
builder.HorizontalChromaSubSampling = options.HorizontalChromaSubSampling;
builder.VerticalChromaSubSampling = options.VerticalChromaSubSampling;
TiffImageEncoder <TPixel> encoder = builder.BuildForImageSharp <TPixel>();
return(encoder.EncodeAsync(ifdWriter, image, cancellationToken));
}
private static async Task GenerateImageAsync(Stream stream, TiffImageEncoderBuilder builder, TiffPixelBuffer <TiffGray8> image)
{
using (TiffFileWriter writer = await TiffFileWriter.OpenAsync(stream, true))
{
TiffStreamOffset ifdOffset;
using (TiffImageFileDirectoryWriter ifdWriter = writer.CreateImageFileDirectory())
{
TiffImageEncoder <TiffGray8> encoder = builder.Build <TiffGray8>();
await encoder.EncodeAsync(ifdWriter, image);
ifdOffset = await ifdWriter.FlushAsync();
}
writer.SetFirstImageFileDirectoryOffset(ifdOffset);
await writer.FlushAsync();
}
}
public async Task TestRoundtrip(bool isTile, int maxDegreeOfParallelism, bool isYCbCr)
{
TiffGray8[] refImage = new TiffGray8[4096 * 4096];
TiffGray8[] testImage = new TiffGray8[4096 * 4096];
var rand = new Random(42);
rand.NextBytes(MemoryMarshal.AsBytes(refImage.AsSpan()));
var builder = new TiffImageEncoderBuilder();
if (isYCbCr)
{
builder.PhotometricInterpretation = TiffPhotometricInterpretation.YCbCr;
builder.HorizontalChromaSubSampling = 2;
builder.VerticalChromaSubSampling = 2;
}
else
{
builder.PhotometricInterpretation = TiffPhotometricInterpretation.BlackIsZero;
builder.Predictor = TiffPredictor.HorizontalDifferencing;
}
builder.Compression = TiffCompression.Lzw;
builder.IsTiled = isTile;
builder.RowsPerStrip = 64;
builder.TileSize = new TiffSize(64, 64);
builder.MaxDegreeOfParallelism = maxDegreeOfParallelism;
var ms = new MemoryStream();
await GenerateImageAsync(ms, builder, TiffPixelBuffer.WrapReadOnly(refImage, 4096, 4096));
ms.Seek(0, SeekOrigin.Begin);
await using TiffFileReader tiff = await TiffFileReader.OpenAsync(ms, leaveOpen : true);
TiffImageDecoder decoder = await tiff.CreateImageDecoderAsync();
await decoder.DecodeAsync(TiffPixelBuffer.Wrap(testImage, 4096, 4096));
Assert.True(refImage.AsSpan().SequenceEqual(testImage.AsSpan()));
}
public DeepZoomRipper(DeepZoomRipperOptions options, HttpClientInitializationOptions httpClientInitializationOptions, string outputFile)
{
_options = options = options ?? DeepZoomRipperOptions.Default;
if (httpClientInitializationOptions == HttpClientInitializationOptions.InitializeWithCookieContainer)
{
_cookieContainer = new CookieContainer();
HttpClientHandler handler = new HttpClientHandler
{
CookieContainer = _cookieContainer
};
_http = new HttpClient(handler)
{
Timeout = Timeout.InfiniteTimeSpan
};
}
else if (httpClientInitializationOptions == HttpClientInitializationOptions.InitializeWithoutCookieContainer)
{
_http = new HttpClient()
{
Timeout = Timeout.InfiniteTimeSpan
};
}
_outputFile = outputFile;
_configuration = Configuration.Default.Clone();
_configuration.MaxDegreeOfParallelism = 1;
var builder = new TiffImageEncoderBuilder();
builder.PhotometricInterpretation = TiffPhotometricInterpretation.YCbCr;
builder.IsTiled = true;
builder.TileSize = new TiffSize(OutputTileSize, OutputTileSize);
builder.HorizontalChromaSubSampling = 2;
builder.VerticalChromaSubSampling = 2;
builder.Compression = TiffCompression.Jpeg;
builder.JpegOptions = new TiffJpegEncodingOptions {
OptimizeCoding = true
};
_encoder = builder.BuildForImageSharp <Rgb24>();
}
public void Setup()
{
TiffGray8[] image = new TiffGray8[8192 * 8192];
_image = TiffPixelBuffer.WrapReadOnly(image, 8192, 8192);
var builder = new TiffImageEncoderBuilder();
builder.PhotometricInterpretation = TiffPhotometricInterpretation.WhiteIsZero;
builder.Compression = Compression;
builder.MaxDegreeOfParallelism = DegreeOfParallelism;
// Strip encoder
builder.IsTiled = false;
builder.RowsPerStrip = 256;
_stripEncoder = builder.Build <TiffGray8>();
// Tile encoder
builder.IsTiled = false;
builder.TileSize = new TiffSize(512, 512);
_tileEncoder = builder.Build <TiffGray8>();
}
public async Task Setup()
{
TiffGray8[] image = new TiffGray8[8192 * 8192];
_scratchSpace = TiffPixelBuffer.Wrap(image, 8192, 8192);
var builder = new TiffImageEncoderBuilder();
builder.PhotometricInterpretation = TiffPhotometricInterpretation.WhiteIsZero;
builder.Compression = Compression;
// Generate a image with many strips
var ms = new MemoryStream();
builder.IsTiled = false;
builder.RowsPerStrip = 256;
await GenerateImageAsync(ms, builder, _scratchSpace);
_stripTestTiff = ms.ToArray();
ms.SetLength(0);
// Generate a image with many tiles
builder.IsTiled = true;
builder.TileSize = new TiffSize(512, 512);
await GenerateImageAsync(ms, builder, _scratchSpace);
_tileTestTiff = ms.ToArray();
_stripReader = await TiffFileReader.OpenAsync(_stripTestTiff);
_stripDecoder = await _stripReader.CreateImageDecoderAsync(new TiffImageDecoderOptions { MaxDegreeOfParallelism = DegreeOfParallelism });
await _stripDecoder.DecodeAsync(_scratchSpace);
_tileReader = await TiffFileReader.OpenAsync(_tileTestTiff);
_tileDecoder = await _tileReader.CreateImageDecoderAsync(new TiffImageDecoderOptions { MaxDegreeOfParallelism = DegreeOfParallelism });
await _tileDecoder.DecodeAsync(_scratchSpace);
}
public async Task Setup()
{
TiffGray8[] image = new TiffGray8[8192 * 8192];
_scratchSpace = TiffPixelBuffer.Wrap(image, 8192, 8192);
var builder = new TiffImageEncoderBuilder();
builder.PhotometricInterpretation = TiffPhotometricInterpretation.BlackIsZero;
builder.Compression = TiffCompression.NoCompression;
// Generate a image with many strips
var ms = new MemoryStream();
builder.IsTiled = false;
builder.RowsPerStrip = 1;
await GenerateImageAsync(ms, builder, _scratchSpace);
_stripTestTiff = ms.ToArray();
ms.SetLength(0);
// Generate a image with many tiles
builder.IsTiled = true;
builder.TileSize = new TiffSize(16, 16); // the minimum tile size
await GenerateImageAsync(ms, builder, _scratchSpace);
_tileTestTiff = ms.ToArray();
_stripReader = await TiffFileReader.OpenAsync(_stripTestTiff);
_stripDecoder = await _stripReader.CreateImageDecoderAsync();
await _stripDecoder.DecodeAsync(_scratchSpace);
_tileReader = await TiffFileReader.OpenAsync(_tileTestTiff);
_tileDecoder = await _tileReader.CreateImageDecoderAsync();
await _tileDecoder.DecodeAsync(_scratchSpace);
}
