private static void testJpegOutput(JpegImage jpeg, CompressionParameters parameters, string jpegFileName, string folderWithExpectedResults)
{
using (FileStream output = new FileStream(jpegFileName, FileMode.Create))
jpeg.WriteJpeg(output, parameters);
FileAssert.AreEqual(jpegFileName, Path.Combine(folderWithExpectedResults, jpegFileName));
}
private static void testJpegOutput(JpegImage jpeg, CompressionParameters parameters, string jpegFileName)
{
using (FileStream output = new FileStream(jpegFileName, FileMode.Create))
jpeg.WriteJpeg(output, parameters);
FileAssert.AreEqual(jpegFileName, Tester.MapExpectedPath(jpegFileName));
}
public static unsafe CompressionHandle CompressInit(CompressionParameters parameters)
{
parameters.Initialize();
byte *pBytes = (byte *)¶meters;
return(lzham_compress_init(pBytes));
}
public void EncodeFromRaw()
{
const string testImage = "obama-240p.raw";
var path = Path.GetFullPath(Path.Combine(TestImageDirectory, testImage));
var imageByte = File.ReadAllBytes(path);
using var image = ImageHelper.FromRaw(imageByte, 427, 240, 427 * 3, 3, true);
using var compressionParameters = new CompressionParameters();
OpenJpeg.SetDefaultEncoderParameters(compressionParameters);
compressionParameters.TcpNumLayers = 1;
compressionParameters.CodingParameterDistortionAllocation = 1;
using var codec = OpenJpeg.CreateCompress(CodecFormat.J2k);
OpenJpeg.SetInfoHandler(codec, new DelegateHandler <MsgCallback>(MsgInfoCallback), IntPtr.Zero);
OpenJpeg.SetWarnHandler(codec, new DelegateHandler <MsgCallback>(MsgWarnCallback), IntPtr.Zero);
OpenJpeg.SetErrorHandler(codec, new DelegateHandler <MsgCallback>(MsgErrorCallback), IntPtr.Zero);
Assert.True(OpenJpeg.SetupEncoder(codec, compressionParameters, image));
var bufferLength = imageByte.Length + 1024;
var outputBuffer = Marshal.AllocHGlobal(bufferLength);
var buffer = new Buffer
{
Data = outputBuffer,
Length = bufferLength,
Position = 0
};
var size = Marshal.SizeOf(buffer);
var userData = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(buffer, userData, false);
using var stream = OpenJpeg.StreamCreate((ulong)buffer.Length, false);
OpenJpeg.StreamSetUserData(stream, userData);
OpenJpeg.StreamSetUserDataLength(stream, buffer.Length);
OpenJpeg.StreamSetWriteFunction(stream, new DelegateHandler <StreamWrite>(StreamWriteCallback));
OpenJpeg.StreamSetReadFunction(stream, new DelegateHandler <StreamRead>(StreamReadCallback));
OpenJpeg.StreamSetSeekFunction(stream, new DelegateHandler <StreamSeek>(StreamSeekCallback));
OpenJpeg.StreamSetSkipFunction(stream, new DelegateHandler <StreamSkip>(StreamSkipCallback));
Assert.True(OpenJpeg.StartCompress(codec, image, stream));
Assert.True(OpenJpeg.Encode(codec, stream));
Assert.True(OpenJpeg.EndCompress(codec, stream));
var outputPath = Path.Combine(ResultDirectory, nameof(this.EncodeFromRaw), $"{Path.GetFileNameWithoutExtension(testImage)}.j2k");
Directory.CreateDirectory(Path.GetDirectoryName(outputPath));
var tmp = Marshal.PtrToStructure <Buffer>(userData);
var output = new byte[tmp.Position];
Marshal.Copy(buffer.Data, output, 0, output.Length);
File.WriteAllBytes(outputPath, output);
Marshal.FreeHGlobal(outputBuffer);
Marshal.FreeHGlobal(userData);
}
public void CompressionParametersCodingParameterDistortionAllocation()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.CodingParameterDistortionAllocation = value;
Assert.Equal(value, parameter.CodingParameterDistortionAllocation);
}
}
public void CompressionParametersTcpNumLayers()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.TcpNumLayers = value;
Assert.Equal(value, parameter.TcpNumLayers);
}
}
public void CompressionParametersIndexOn()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.IndexOn = value;
Assert.Equal(value, parameter.IndexOn);
}
}
public void CompressionParametersSubsamplingDy()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.SubsamplingDy = value;
Assert.Equal(value, parameter.SubsamplingDy);
}
}
public void CompressionParametersJpwlSensitivitySize()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.JpwlSensitivitySize = value;
Assert.Equal(value, parameter.JpwlSensitivitySize);
}
}
public void CompressionParametersRegionSize()
{
using var parameter = new CompressionParameters();
foreach (var value in new ushort[] { 0, 1, 10 })
{
parameter.RegionSize = value;
Assert.Equal(value, parameter.RegionSize);
}
}
public void CompressionParametersCodingParameterCinema()
{
using var parameter = new CompressionParameters();
foreach (var value in Enum.GetValues(typeof(CinemaMode)).Cast <CinemaMode>())
{
parameter.CodingParameterCinema = value;
Assert.Equal(value, parameter.CodingParameterCinema);
}
}
public void CompressionParametersCodingParameterFixedQuality()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.CodingParameterFixedQuality = value;
Assert.Equal(value, parameter.CodingParameterFixedQuality);
}
}
public void CompressionParametersNumProgressionOrderChanges()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0u, 1u, 10u })
{
parameter.NumProgressionOrderChanges = value;
Assert.Equal(value, parameter.NumProgressionOrderChanges);
}
}
public void CompressionParametersNumResolution()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.NumResolution = value;
Assert.Equal(value, parameter.NumResolution);
}
}
public void CompressionParametersMode()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.Mode = value;
Assert.Equal(value, parameter.Mode);
}
}
public void CompressionParametersMaximumComponentSize()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.MaximumComponentSize = value;
Assert.Equal(value, parameter.MaximumComponentSize);
}
}
public void CompressionParametersCodingFormat()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.CodingFormat = value;
Assert.Equal(value, parameter.CodingFormat);
}
}
public void CompressionParametersTilePartOn()
{
using var parameter = new CompressionParameters();
foreach (var value in new sbyte[] { -10, -1, 0, 1, 10 })
{
parameter.TilePartOn = value;
Assert.Equal(value, parameter.TilePartOn);
}
}
public void CompressionParametersCodingParameterRegionSize()
{
using var parameter = new CompressionParameters();
foreach (var value in Enum.GetValues(typeof(RegionSizeCapabilities)).Cast <RegionSizeCapabilities>())
{
parameter.CodingParameterRegionSize = value;
Assert.Equal(value, parameter.CodingParameterRegionSize);
}
}
public void CompressionParametersTileSizeOn()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { true, false })
{
parameter.TileSizeOn = value;
Assert.Equal(value, parameter.TileSizeOn);
}
}
public void CompressionParametersJpwlHeaderProtectionMainHeader()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.JpwlHeaderProtectionMainHeader = value;
Assert.Equal(value, parameter.JpwlHeaderProtectionMainHeader);
}
}
public JpegFactory(int quality = 100, int smoothingFactor = 1, bool progressive = false)
{
compressionParams = new CompressionParameters
{
Quality = quality,
SimpleProgressive = progressive,
SmoothingFactor = smoothingFactor
};
}
public void CompressionParametersCodeBlockWidthInitial()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.CodeBlockWidthInitial = value;
Assert.Equal(value, parameter.CodeBlockWidthInitial);
}
}
public void CompressionParametersProgressionOrder()
{
using var parameter = new CompressionParameters();
foreach (var value in Enum.GetValues(typeof(ProgressionOrder)).Cast <ProgressionOrder>())
{
parameter.ProgressionOrder = value;
Assert.Equal(value, parameter.ProgressionOrder);
}
}
public void CompressionParametersIrreversible()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { true, false })
{
parameter.Irreversible = value;
Assert.Equal(value, parameter.Irreversible);
}
}
public void CompressionParametersRegionOfInterestShift()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.RegionOfInterestShift = value;
Assert.Equal(value, parameter.RegionOfInterestShift);
}
}
public void CompressionParametersResSpec()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.ResSpec = value;
Assert.Equal(value, parameter.ResSpec);
}
}
public void CompressionParametersImageOffsetY0()
{
using var parameter = new CompressionParameters();
foreach (var value in new[] { 0, 1, 10 })
{
parameter.ImageOffsetY0 = value;
Assert.Equal(value, parameter.ImageOffsetY0);
}
}
public override void Save(Image i, Stream dest)
{
BitMiracle.LibJpeg.JpegImage j = BitMiracle.LibJpeg.JpegImage.FromBitmap((System.Drawing.Bitmap)i);
CompressionParameters c = new CompressionParameters();
c.Quality = 100;
c.SimpleProgressive = false;
j.WriteJpeg(dest, c);
j.Dispose();
System.GC.Collect();
}
private static CompressionParameters ToCompressionParameters(DicomJpegParams parameters)
{
var compressionParams = new CompressionParameters();
if (parameters != null)
{
compressionParams.Quality = parameters.Quality;
compressionParams.SmoothingFactor = parameters.SmoothingFactor;
}
return(compressionParams);
}
