public void Decode(DcmDataset dataset, DcmPixelData oldPixelData, DcmPixelData newPixelData, DcmCodecParameters parameters)
{
DcmRleCodecParameters rleParams = parameters as DcmRleCodecParameters;
if (rleParams == null)
rleParams = GetDefaultParameters() as DcmRleCodecParameters;
int pixelCount = oldPixelData.ImageWidth * oldPixelData.ImageHeight;
int numberOfSegments = oldPixelData.BytesAllocated * oldPixelData.SamplesPerPixel;
byte[] frameData = new byte[newPixelData.UncompressedFrameSize];
for (int i = 0; i < oldPixelData.NumberOfFrames; i++)
{
IList<ByteBuffer> rleData = oldPixelData.GetFrameFragments(i);
RLEDecoder decoder = new RLEDecoder(rleData);
if (decoder.NumberOfSegments != numberOfSegments)
throw new DicomCodecException("Unexpected number of RLE segments!");
for (int s = 0; s < numberOfSegments; s++)
{
int sample = s / newPixelData.BytesAllocated;
int sabyte = s % newPixelData.BytesAllocated;
int pos, offset;
if (newPixelData.PlanarConfiguration == 0)
{
pos = sample * newPixelData.BytesAllocated;
offset = newPixelData.SamplesPerPixel * newPixelData.BytesAllocated;
}
else
{
pos = sample * newPixelData.BytesAllocated * pixelCount;
offset = newPixelData.BytesAllocated;
}
if (rleParams.ReverseByteOrder)
pos += sabyte;
else
pos += newPixelData.BytesAllocated - sabyte - 1;
decoder.DecodeSegment(s, frameData, pos, offset);
}
newPixelData.AddFrame(frameData);
}
}
/// <summary>
/// Loads the DICOM file and changes the transfer syntax if needed. (Internal)
/// </summary>
/// <param name="client">C-Store Client</param>
public void Load(CStoreClient client)
{
if (_loaded)
{
return;
}
try {
DicomTransferSyntax tx = null;
foreach (DcmPresContext pc in client.Associate.GetPresentationContexts())
{
if (pc.Result == DcmPresContextResult.Accept && pc.AbstractSyntax == _sopClass)
{
tx = pc.AcceptedTransferSyntax;
break;
}
}
if (tx == null)
{
throw new DicomNetworkException("No accepted presentation contexts for abstract syntax: " + _sopClass.Description);
}
// Possible to stream from file?
if (!client.DisableFileStreaming && tx == TransferSyntax)
{
using (FileStream fs = DicomFileFormat.GetDatasetStream(_fileName)) {
_datasetSize = Convert.ToUInt32(fs.Length - fs.Position);
fs.Close();
}
return;
}
DcmCodecParameters codecParams = null;
if (tx == client.PreferredTransferSyntax)
{
codecParams = client.PreferredTransferSyntaxParams;
}
DicomFileFormat ff = new DicomFileFormat();
ff.Load(FileName, DicomReadOptions.DefaultWithoutDeferredLoading);
if (_originalTransferSyntax != tx)
{
if (_originalTransferSyntax.IsEncapsulated)
{
// Dataset is compressed... decompress
try {
ff.ChangeTransferSytnax(DicomTransferSyntax.ExplicitVRLittleEndian, null);
}
catch {
client.Log.Error("{0} -> Unable to change transfer syntax:\n\tclass: {1}\n\told: {2}\n\tnew: {3}\n\treason: {4}\n\tcodecs: {5} - {6}",
client.LogID, SOPClassUID.Description, _originalTransferSyntax, DicomTransferSyntax.ExplicitVRLittleEndian,
#if DEBUG
HasError ? "Unknown" : Error.ToString(),
#else
HasError ? "Unknown" : Error.Message,
#endif
DicomCodec.HasCodec(_originalTransferSyntax), DicomCodec.HasCodec(DicomTransferSyntax.ExplicitVRLittleEndian));
throw;
}
}
if (tx.IsEncapsulated)
{
// Dataset needs to be compressed
try {
ff.ChangeTransferSytnax(tx, codecParams);
}
catch {
client.Log.Error("{0} -> Unable to change transfer syntax:\n\tclass: {1}\n\told: {2}\n\tnew: {3}\n\treason: {4}\n\tcodecs: {5} - {6}",
client.LogID, SOPClassUID.Description, ff.Dataset.InternalTransferSyntax, tx,
#if DEBUG
HasError ? "Unknown" : Error.ToString(),
#else
HasError ? "Unknown" : Error.Message,
#endif
DicomCodec.HasCodec(ff.Dataset.InternalTransferSyntax), DicomCodec.HasCodec(tx));
throw;
}
}
}
_dataset = ff.Dataset;
_datasetSize = _dataset.CalculateWriteLength(tx, DicomWriteOptions.Default);
_transferSyntax = tx;
}
catch (Exception e) {
_dataset = null;
_transferSyntax = _originalTransferSyntax;
_status = DcmStatus.ProcessingFailure;
_exception = e;
}
finally {
_loaded = true;
}
}
public void ChangeTransferSyntax(DicomTransferSyntax newTransferSyntax, DcmCodecParameters parameters)
{
DicomTransferSyntax oldTransferSyntax = InternalTransferSyntax;
if (oldTransferSyntax == newTransferSyntax)
return;
if (oldTransferSyntax.IsEncapsulated && newTransferSyntax.IsEncapsulated) {
ChangeTransferSyntax(DicomTransferSyntax.ExplicitVRLittleEndian, parameters);
oldTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian;
}
if (Contains(DicomTags.PixelData)) {
DcmPixelData oldPixelData = new DcmPixelData(this);
DcmPixelData newPixelData = new DcmPixelData(newTransferSyntax, oldPixelData);
if (oldTransferSyntax.IsEncapsulated) {
IDcmCodec codec = DicomCodec.GetCodec(oldTransferSyntax);
codec.Decode(this, oldPixelData, newPixelData, parameters);
}
else if (newTransferSyntax.IsEncapsulated) {
IDcmCodec codec = DicomCodec.GetCodec(newTransferSyntax);
codec.Encode(this, oldPixelData, newPixelData, parameters);
}
else {
for (int i = 0; i < oldPixelData.NumberOfFrames; i++) {
byte[] data = oldPixelData.GetFrameDataU8(i);
newPixelData.AddFrame(data);
}
}
newPixelData.UpdateDataset(this);
}
SetInternalTransferSyntax(newTransferSyntax);
}
public void Decode(DcmDataset dataset, DcmPixelData oldPixelData, DcmPixelData newPixelData, DcmCodecParameters parameters, int frame)
{
DcmRleCodecParameters rleParams = parameters as DcmRleCodecParameters;
if (rleParams == null)
{
rleParams = GetDefaultParameters() as DcmRleCodecParameters;
}
int pixelCount = oldPixelData.ImageWidth * oldPixelData.ImageHeight;
int numberOfSegments = oldPixelData.BytesAllocated * oldPixelData.SamplesPerPixel;
byte[] frameData = new byte[newPixelData.UncompressedFrameSize];
IList <ByteBuffer> rleData = oldPixelData.GetFrameFragments(frame);
RLEDecoder decoder = new RLEDecoder(rleData);
if (decoder.NumberOfSegments != numberOfSegments)
{
throw new DicomCodecException("Unexpected number of RLE segments!");
}
for (int s = 0; s < numberOfSegments; s++)
{
int sample = s / newPixelData.BytesAllocated;
int sabyte = s % newPixelData.BytesAllocated;
int pos, offset;
if (newPixelData.PlanarConfiguration == 0)
{
pos = sample * newPixelData.BytesAllocated;
offset = newPixelData.SamplesPerPixel * newPixelData.BytesAllocated;
}
else
{
pos = sample * newPixelData.BytesAllocated * pixelCount;
offset = newPixelData.BytesAllocated;
}
if (rleParams.ReverseByteOrder)
{
pos += sabyte;
}
else
{
pos += newPixelData.BytesAllocated - sabyte - 1;
}
decoder.DecodeSegment(s, frameData, pos, offset);
}
newPixelData.AddFrame(frameData);
}
public void Encode(DcmDataset dataset, DcmPixelData oldPixelData, DcmPixelData newPixelData, DcmCodecParameters parameters)
{
DcmRleCodecParameters rleParams = parameters as DcmRleCodecParameters;
if (rleParams == null)
rleParams = GetDefaultParameters() as DcmRleCodecParameters;
int pixelCount = oldPixelData.ImageWidth * oldPixelData.ImageHeight;
int numberOfSegments = oldPixelData.BytesAllocated * oldPixelData.SamplesPerPixel;
for (int i = 0; i < oldPixelData.NumberOfFrames; i++)
{
RLEEncoder encoder = new RLEEncoder();
byte[] frameData = oldPixelData.GetFrameDataU8(i);
for (int s = 0; s < numberOfSegments; s++)
{
encoder.NextSegment();
int sample = s / oldPixelData.BytesAllocated;
int sabyte = s % oldPixelData.BytesAllocated;
int pos;
int offset;
if (newPixelData.PlanarConfiguration == 0)
{
pos = sample * oldPixelData.BytesAllocated;
offset = numberOfSegments;
}
else
{
pos = sample * oldPixelData.BytesAllocated * pixelCount;
offset = oldPixelData.BytesAllocated;
}
if (rleParams.ReverseByteOrder)
pos += sabyte;
else
pos += oldPixelData.BytesAllocated - sabyte - 1;
for (int p = 0; p < pixelCount; p++)
{
if (pos >= frameData.Length)
throw new DicomCodecException("");
encoder.Encode(frameData[pos]);
pos += offset;
}
encoder.Flush();
}
encoder.MakeEvenLength();
newPixelData.AddFrame(encoder.GetBuffer());
}
}
public void Decode(DcmDataset dataset, DcmPixelData oldPixelData, DcmPixelData newPixelData, DcmCodecParameters parameters)
{
if (oldPixelData.NumberOfFrames == 0) return;
// Determine JPEG image precision and assert that the implemented codec supports this precision
int precision;
try
{
precision = JpegHelper.ScanHeaderForBitDepth(oldPixelData);
}
catch (DicomCodecException)
{
precision = oldPixelData.BitsStored;
}
AssertImagePrecision(precision);
// Ensure consistency in the new pixel data header
if (precision > 8)
newPixelData.BitsAllocated = 16;
else if (newPixelData.BitsStored <= 8)
newPixelData.BitsAllocated = 8;
// Set up new pixel data specifics
newPixelData.PhotometricInterpretation = newPixelData.PhotometricInterpretation.Equals("YBR_FULL_422") ||
newPixelData.PhotometricInterpretation.Equals("YBR_PARTIAL_422")
? "YBR_FULL"
: oldPixelData.PhotometricInterpretation;
if (newPixelData.PhotometricInterpretation.Equals("YBR_FULL")) newPixelData.PlanarConfiguration = 1;
try
{
for (int j = 0; j < oldPixelData.NumberOfFrames; ++j)
{
var frameData = new byte[newPixelData.UncompressedFrameSize];
var jpegStream = new MemoryStream(oldPixelData.GetFrameDataU8(j));
// Decode JPEG from stream
var decoder = new JpegDecoder(jpegStream);
var jpegDecoded = decoder.Decode();
var img = jpegDecoded.Image;
// Init Buffer
int w = img.Width;
int h = img.Height;
var pixelsFromJpeg = img.Raster;
// Copy FluxJpeg buffer into frame data array
/*
int comps = pixelsFromJpeg.GetLength(0);
int preIncr = newPixelData.BytesAllocated - comps;
if (preIncr < 0)
throw new InvalidOperationException(
String.Format("Number of JPEG components: {0} exceeds number of bytes allocated: {1}",
comps, newPixelData.BytesAllocated));
*/
int i = 0;
for (int y = 0; y < h; ++y)
{
for (int x = 0; x < w; ++x)
{
var pixel = pixelsFromJpeg[0][x, y];
frameData[i++] = (byte)((pixel >> 8) & 0xff);
frameData[i++] = (byte)(pixel & 0xff);
// for (int k = 0; k < preIncr; ++k) frameData[i++] = 0xff;
// for (int k = 0; k < comps; ++k) frameData[i++] = pixelsFromJpeg[k][x, y];
}
}
oldPixelData.Unload();
if (newPixelData.IsPlanar)
DcmCodecHelper.ChangePlanarConfiguration(frameData,
frameData.Length / newPixelData.BytesAllocated,
newPixelData.BitsAllocated,
newPixelData.SamplesPerPixel, 0);
newPixelData.AddFrame(frameData);
}
}
catch (Exception e)
{
Debug.Log.Error("Failed to decode JPEG image: {0}, reason: {1}", e.StackTrace, e.Message);
}
}
public void Encode(DcmDataset dataset, DcmPixelData oldPixelData, DcmPixelData newPixelData, DcmCodecParameters parameters)
{
DcmRleCodecParameters rleParams = parameters as DcmRleCodecParameters;
if (rleParams == null)
{
rleParams = GetDefaultParameters() as DcmRleCodecParameters;
}
int pixelCount = oldPixelData.ImageWidth * oldPixelData.ImageHeight;
int numberOfSegments = oldPixelData.BytesAllocated * oldPixelData.SamplesPerPixel;
for (int i = 0; i < oldPixelData.NumberOfFrames; i++)
{
RLEEncoder encoder = new RLEEncoder();
byte[] frameData = oldPixelData.GetFrameDataU8(i);
for (int s = 0; s < numberOfSegments; s++)
{
encoder.NextSegment();
int sample = s / oldPixelData.BytesAllocated;
int sabyte = s % oldPixelData.BytesAllocated;
int pos;
int offset;
if (newPixelData.PlanarConfiguration == 0)
{
pos = sample * oldPixelData.BytesAllocated;
offset = numberOfSegments;
}
else
{
pos = sample * oldPixelData.BytesAllocated * pixelCount;
offset = oldPixelData.BytesAllocated;
}
if (rleParams.ReverseByteOrder)
{
pos += sabyte;
}
else
{
pos += oldPixelData.BytesAllocated - sabyte - 1;
}
for (int p = 0; p < pixelCount; p++)
{
if (pos >= frameData.Length)
{
throw new DicomCodecException("");
}
encoder.Encode(frameData[pos]);
pos += offset;
}
encoder.Flush();
}
encoder.MakeEvenLength();
newPixelData.AddFrame(encoder.GetBuffer());
}
}
public void Encode(DcmDataset dataset, DcmPixelData oldPixelData, DcmPixelData newPixelData, DcmCodecParameters parameters)
{
throw new NotSupportedException("JPEG encoding currently not supported");
}
/// <summary>
/// Changes transfer syntax of dataset and updates file meta information
/// </summary>
/// <param name="ts">New transfer syntax</param>
/// <param name="parameters">Encode/Decode params</param>
public void ChangeTransferSytnax(DicomTransferSyntax ts, DcmCodecParameters parameters)
{
Dataset.ChangeTransferSyntax(ts, parameters);
FileMetaInfo.TransferSyntax = ts;
}
/// <summary>
/// Changes transfer syntax of dataset and updates file meta information
/// </summary>
/// <param name="ts">New transfer syntax</param>
/// <param name="parameters">Encode/Decode params</param>
public void ChangeTransferSytnax(DicomTransferSyntax ts, DcmCodecParameters parameters) {
Dataset.ChangeTransferSyntax(ts, parameters);
FileMetaInfo.TransferSyntax = ts;
}
public void Decode(DcmDataset dataset, DcmPixelData oldPixelData, DcmPixelData newPixelData, DcmCodecParameters parameters)
{
if (oldPixelData.NumberOfFrames == 0)
{
return;
}
// Determine JPEG image precision and assert that the implemented codec supports this precision
int precision;
try
{
precision = JpegHelper.ScanHeaderForBitDepth(oldPixelData);
}
catch (DicomCodecException)
{
precision = oldPixelData.BitsStored;
}
AssertImagePrecision(precision);
// Ensure consistency in the new pixel data header
if (precision > 8)
{
newPixelData.BitsAllocated = 16;
}
else if (newPixelData.BitsStored <= 8)
{
newPixelData.BitsAllocated = 8;
}
// Set up new pixel data specifics
newPixelData.PhotometricInterpretation = newPixelData.PhotometricInterpretation.Equals("YBR_FULL_422") ||
newPixelData.PhotometricInterpretation.Equals("YBR_PARTIAL_422")
? "YBR_FULL"
: oldPixelData.PhotometricInterpretation;
if (newPixelData.PhotometricInterpretation.Equals("YBR_FULL"))
{
newPixelData.PlanarConfiguration = 1;
}
try
{
for (int j = 0; j < oldPixelData.NumberOfFrames; ++j)
{
var frameData = new byte[newPixelData.UncompressedFrameSize];
var jpegStream = new MemoryStream(oldPixelData.GetFrameDataU8(j));
// Decode JPEG from stream
var decoder = new JpegDecoder(jpegStream);
var jpegDecoded = decoder.Decode();
var img = jpegDecoded.Image;
// Init Buffer
int w = img.Width;
int h = img.Height;
var pixelsFromJpeg = img.Raster;
// Copy FluxJpeg buffer into frame data array
/*
* int comps = pixelsFromJpeg.GetLength(0);
* int preIncr = newPixelData.BytesAllocated - comps;
*
* if (preIncr < 0)
* throw new InvalidOperationException(
* String.Format("Number of JPEG components: {0} exceeds number of bytes allocated: {1}",
* comps, newPixelData.BytesAllocated));
*/
int i = 0;
for (int y = 0; y < h; ++y)
{
for (int x = 0; x < w; ++x)
{
var pixel = pixelsFromJpeg[0][x, y];
frameData[i++] = (byte)((pixel >> 8) & 0xff);
frameData[i++] = (byte)(pixel & 0xff);
// for (int k = 0; k < preIncr; ++k) frameData[i++] = 0xff;
// for (int k = 0; k < comps; ++k) frameData[i++] = pixelsFromJpeg[k][x, y];
}
}
oldPixelData.Unload();
if (newPixelData.IsPlanar)
{
DcmCodecHelper.ChangePlanarConfiguration(frameData,
frameData.Length / newPixelData.BytesAllocated,
newPixelData.BitsAllocated,
newPixelData.SamplesPerPixel, 0);
}
newPixelData.AddFrame(frameData);
}
}
catch (Exception e)
{
Debug.Log.Error("Failed to decode JPEG image: {0}, reason: {1}", e.StackTrace, e.Message);
}
}
public void Encode(DcmDataset dataset, DcmPixelData oldPixelData, DcmPixelData newPixelData, DcmCodecParameters parameters)
{
throw new NotSupportedException("JPEG encoding currently not supported");
}
