public static DicomFile ChangeTransferSyntax( this DicomFile file, DicomTransferSyntax syntax, DicomCodecParams parameters = null) { return(Clone(file, syntax, parameters)); }
private static DicomDataset Decode( DicomDataset oldDataset, DicomTransferSyntax outSyntax, IDicomCodec codec, DicomCodecParams parameters) { if (codec == null) { throw new DicomCodecException("Decoding dataset with transfer syntax: {0} is not supported. See here to get help resolving the reason: https://github.com/fo-dicom/fo-dicom/wiki/Native-codecs-on-.NET", oldDataset.InternalTransferSyntax); } var oldPixelData = DicomPixelData.Create(oldDataset); var newDataset = oldDataset.Clone(); newDataset.InternalTransferSyntax = outSyntax; var newPixelData = DicomPixelData.Create(newDataset, true); codec.Decode(oldPixelData, newPixelData, parameters); ProcessOverlays(oldDataset, newDataset); newDataset.RecalculateGroupLengths(false); return(newDataset); }
private static DicomDataset Decode( DicomDataset oldDataset, DicomTransferSyntax outSyntax, IDicomCodec codec, DicomCodecParams parameters) { if (codec == null) { throw new DicomCodecException("Decoding dataset with transfer syntax: {0} is not supported.", oldDataset.InternalTransferSyntax); } var oldPixelData = DicomPixelData.Create(oldDataset); var newDataset = oldDataset.Clone(); newDataset.InternalTransferSyntax = outSyntax; var newPixelData = DicomPixelData.Create(newDataset, true); codec.Decode(oldPixelData, newPixelData, parameters); ProcessOverlays(oldDataset, newDataset); newDataset.RecalculateGroupLengths(false); return(newDataset); }
public override void Encode( DicomPixelData oldPixelData, DicomPixelData newPixelData, DicomCodecParams parameters) { if (oldPixelData.NumberOfFrames == 0) return; // IJG eats the extra padding bits. Is there a better way to test for this? if (oldPixelData.BitsAllocated == 16 && oldPixelData.BitsStored <= 8) { // check for embedded overlays? newPixelData.BitsAllocated = 8; } var jparams = parameters as DicomJpegParams ?? GetDefaultParameters() as DicomJpegParams; var codec = GetCodec(oldPixelData.BitsStored, jparams); var oldNativeData = oldPixelData.ToNativePixelData(); var newNativeData = newPixelData.ToNativePixelData(); var jNativeParams = jparams.ToNativeJpegParameters(); for (var frame = 0; frame < oldPixelData.NumberOfFrames; frame++) { codec.Encode(oldNativeData, newNativeData, jNativeParams, frame); } }
public override void Encode( DicomPixelData oldPixelData, DicomPixelData newPixelData, DicomCodecParams parameters) { if (oldPixelData.NumberOfFrames == 0) { return; } // IJG eats the extra padding bits. Is there a better way to test for this? if (oldPixelData.BitsAllocated == 16 && oldPixelData.BitsStored <= 8) { // check for embedded overlays? newPixelData.BitsAllocated = 8; } var jparams = parameters as DicomJpegParams ?? GetDefaultParameters() as DicomJpegParams; var codec = GetCodec(oldPixelData.BitsStored, jparams); var oldNativeData = oldPixelData.ToNativePixelData(); var newNativeData = newPixelData.ToNativePixelData(); var jNativeParams = jparams.ToNativeJpegParameters(); for (var frame = 0; frame < oldPixelData.NumberOfFrames; frame++) { codec.Encode(oldNativeData, newNativeData, jNativeParams, frame); } }
public static DicomDataset ChangeTransferSyntax( this DicomDataset dataset, DicomTransferSyntax syntax, DicomCodecParams parameters = null) { return(Clone(dataset, syntax, parameters)); }
public override void Encode( DicomPixelData oldPixelData, DicomPixelData newPixelData, DicomCodecParams parameters) { var pixelCount = oldPixelData.Width * oldPixelData.Height; var numberOfSegments = oldPixelData.BytesAllocated * oldPixelData.SamplesPerPixel; for (var frame = 0; frame < oldPixelData.NumberOfFrames; frame++) { var frameData = oldPixelData.GetFrame(frame); var frameArray = frameData.Data; using (var encoder = new RLEEncoder()) { for (var s = 0; s < numberOfSegments; s++) { encoder.NextSegment(); var sample = s / oldPixelData.BytesAllocated; var sabyte = s % oldPixelData.BytesAllocated; int pos; int offset; if (newPixelData.PlanarConfiguration == PlanarConfiguration.Interleaved) { pos = sample * oldPixelData.BytesAllocated; offset = numberOfSegments; } else { pos = sample * oldPixelData.BytesAllocated * pixelCount; offset = oldPixelData.BytesAllocated; } pos += oldPixelData.BytesAllocated - sabyte - 1; for (var p = 0; p < pixelCount; p++) { if (pos >= frameArray.Length) { throw new InvalidOperationException("Read position is past end of frame buffer"); } encoder.Encode(frameArray[pos]); pos += offset; } encoder.Flush(); } encoder.MakeEvenLength(); var data = encoder.GetBuffer(); newPixelData.AddFrame(data); } } }
/// <summary> /// Create a copy of the specified DICOM file with requested transfer syntax. /// </summary> /// <param name="file">DICOM file to copy.</param> /// <param name="syntax">Requested transfer syntax for the created DICOM file.</param> /// <param name="parameters">Codec parameters.</param> /// <returns>DICOM file with modified transfer syntax.</returns> public static DicomFile Clone( this DicomFile file, DicomTransferSyntax syntax, DicomCodecParams parameters = null) { var transcoder = new DicomTranscoder(file.FileMetaInfo.TransferSyntax, syntax, null, parameters); return(transcoder.Transcode(file)); }
/// <summary> /// Create a copy of the specified DICOM dataset with requested transfer syntax. /// </summary> /// <param name="dataset">DICOM dataset to copy.</param> /// <param name="syntax">Requested transfer syntax for the created DICOM dataset.</param> /// <param name="parameters">Codec parameters.</param> /// <returns>DICOM dataset with modified transfer syntax.</returns> public static DicomDataset Clone( this DicomDataset dataset, DicomTransferSyntax syntax, DicomCodecParams parameters = null) { var transcoder = new DicomTranscoder(dataset.InternalTransferSyntax, syntax, null, parameters); return(transcoder.Transcode(dataset)); }
public override void Decode( DicomPixelData oldPixelData, DicomPixelData newPixelData, DicomCodecParams parameters) { if (oldPixelData.NumberOfFrames == 0) { return; } // IJG eats the extra padding bits. Is there a better way to test for this? if (newPixelData.BitsAllocated == 16 && newPixelData.BitsStored <= 8) { // check for embedded overlays here or below? newPixelData.BitsAllocated = 8; } var jparams = parameters as DicomJpegParams ?? GetDefaultParameters() as DicomJpegParams; var oldNativeData = oldPixelData.ToNativePixelData(); int precision; try { try { precision = JpegHelper.ScanJpegForBitDepth(oldPixelData); } catch { // if the internal scanner chokes on an image, try again using ijg precision = new Jpeg12Codec(JpegMode.Baseline, 0, 0).ScanHeaderForPrecision(oldNativeData); } } catch { // the old scanner choked on several valid images... // assume the correct encoder was used and let libijg handle the rest precision = oldPixelData.BitsStored; } if (newPixelData.BitsStored <= 8 && precision > 8) { newPixelData.BitsAllocated = 16; // embedded overlay? } var codec = GetCodec(precision, jparams); var newNativeData = newPixelData.ToNativePixelData(); var jNativeParams = jparams.ToNativeJpegParameters(); for (var frame = 0; frame < oldPixelData.NumberOfFrames; frame++) { codec.Decode(oldNativeData, newNativeData, jNativeParams, frame); } }
/// <summary> /// Initializes an instance of <see cref="DicomTranscoder"/>. /// </summary> /// <param name="inputSyntax">Input transfer syntax.</param> /// <param name="outputSyntax">Output transfer syntax.</param> /// <param name="inputCodecParams">Input codec parameters.</param> /// <param name="outputCodecParams">Output codec parameters.</param> public DicomTranscoder( DicomTransferSyntax inputSyntax, DicomTransferSyntax outputSyntax, DicomCodecParams inputCodecParams = null, DicomCodecParams outputCodecParams = null) { InputSyntax = inputSyntax; OutputSyntax = outputSyntax; InputCodecParams = inputCodecParams ?? DefaultInputCodecParams(inputSyntax); OutputCodecParams = outputCodecParams; }
/// <summary> /// Initializes an instance of <see cref="DicomTranscoder"/>. /// </summary> /// <param name="inputSyntax">Input transfer syntax.</param> /// <param name="outputSyntax">Output transfer syntax.</param> /// <param name="inputCodecParams">Input codec parameters.</param> /// <param name="outputCodecParams">Output codec parameters.</param> public DicomTranscoder( DicomTransferSyntax inputSyntax, DicomTransferSyntax outputSyntax, DicomCodecParams inputCodecParams = null, DicomCodecParams outputCodecParams = null) { InputSyntax = inputSyntax; OutputSyntax = outputSyntax; InputCodecParams = inputCodecParams; OutputCodecParams = outputCodecParams; }
public override void Decode( DicomPixelData oldPixelData, DicomPixelData newPixelData, DicomCodecParams parameters) { for (var frame = 0; frame < oldPixelData.NumberOfFrames; frame++) { var rleData = oldPixelData.GetFrame(frame); // Create new frame data of even length var frameSize = newPixelData.UncompressedFrameSize; if ((frameSize & 1) == 1) { ++frameSize; } var frameData = new MemoryByteBuffer(new byte[frameSize]); var pixelCount = oldPixelData.Width * oldPixelData.Height; var numberOfSegments = oldPixelData.BytesAllocated * oldPixelData.SamplesPerPixel; var decoder = new RLEDecoder(rleData); if (decoder.NumberOfSegments != numberOfSegments) { throw new InvalidOperationException("Unexpected number of RLE segments!"); } for (var s = 0; s < numberOfSegments; s++) { var sample = s / newPixelData.BytesAllocated; var sabyte = s % newPixelData.BytesAllocated; int pos, offset; if (newPixelData.PlanarConfiguration == PlanarConfiguration.Interleaved) { pos = sample * newPixelData.BytesAllocated; offset = newPixelData.SamplesPerPixel * newPixelData.BytesAllocated; } else { pos = sample * newPixelData.BytesAllocated * pixelCount; offset = newPixelData.BytesAllocated; } pos += newPixelData.BytesAllocated - sabyte - 1; decoder.DecodeSegment(s, frameData, pos, offset); } newPixelData.AddFrame(frameData); } }
/// <summary> /// Initializes an instance of <see cref="DicomTranscoder"/>. /// </summary> /// <param name="inputSyntax">Input transfer syntax.</param> /// <param name="outputSyntax">Output transfer syntax.</param> /// <param name="inputCodecParams">Input codec parameters.</param> /// <param name="outputCodecParams">Output codec parameters.</param> public DicomTranscoder( DicomTransferSyntax inputSyntax, DicomTransferSyntax outputSyntax, DicomCodecParams inputCodecParams = null, DicomCodecParams outputCodecParams = null) { InputSyntax = inputSyntax; OutputSyntax = outputSyntax; InputCodecParams = inputCodecParams ?? DefaultInputCodecParams(inputSyntax); OutputCodecParams = outputCodecParams; _inputCodec = new Lazy <IDicomCodec>(() => InitializeCodec(InputSyntax)); _outputCodec = new Lazy <IDicomCodec>(() => InitializeCodec(OutputSyntax)); }
public override void Decode( DicomPixelData oldPixelData, DicomPixelData newPixelData, DicomCodecParams parameters) { if (oldPixelData.NumberOfFrames == 0) return; // IJG eats the extra padding bits. Is there a better way to test for this? if (newPixelData.BitsAllocated == 16 && newPixelData.BitsStored <= 8) { // check for embedded overlays here or below? newPixelData.BitsAllocated = 8; } var jparams = parameters as DicomJpegParams ?? GetDefaultParameters() as DicomJpegParams; var oldNativeData = oldPixelData.ToNativePixelData(); int precision; try { try { precision = JpegHelper.ScanJpegForBitDepth(oldPixelData); } catch { // if the internal scanner chokes on an image, try again using ijg precision = new Jpeg12Codec(JpegMode.Baseline, 0, 0).ScanHeaderForPrecision(oldNativeData); } } catch { // the old scanner choked on several valid images... // assume the correct encoder was used and let libijg handle the rest precision = oldPixelData.BitsStored; } if (newPixelData.BitsStored <= 8 && precision > 8) newPixelData.BitsAllocated = 16; // embedded overlay? var codec = GetCodec(precision, jparams); var newNativeData = newPixelData.ToNativePixelData(); var jNativeParams = jparams.ToNativeJpegParameters(); for (var frame = 0; frame < oldPixelData.NumberOfFrames; frame++) { codec.Decode(oldNativeData, newNativeData, jNativeParams, frame); } }
private static DicomDataset Encode( DicomDataset oldDataset, DicomTransferSyntax outSyntax, IDicomCodec codec, DicomCodecParams parameters) { if (codec == null) { throw new DicomCodecException("Encoding dataset to transfer syntax: {0} is not supported.", outSyntax); } var oldPixelData = DicomPixelData.Create(oldDataset); var newDataset = oldDataset.Clone(); newDataset.InternalTransferSyntax = outSyntax; var newPixelData = DicomPixelData.Create(newDataset, true); codec.Encode(oldPixelData, newPixelData, parameters); if (outSyntax.IsLossy && newPixelData.NumberOfFrames > 0) { newDataset.AddOrUpdate(new DicomCodeString(DicomTag.LossyImageCompression, "01")); var methods = new List <string>(); if (newDataset.Contains(DicomTag.LossyImageCompressionMethod)) { methods.AddRange(newDataset.Get <string[]>(DicomTag.LossyImageCompressionMethod)); } methods.Add(outSyntax.LossyCompressionMethod); newDataset.AddOrUpdate(new DicomCodeString(DicomTag.LossyImageCompressionMethod, methods.ToArray())); double oldSize = oldPixelData.GetFrame(0).Size; double newSize = newPixelData.GetFrame(0).Size; var ratio = string.Format("{0:0.000}", oldSize / newSize); newDataset.AddOrUpdate(new DicomDecimalString(DicomTag.LossyImageCompressionRatio, ratio)); } ProcessOverlays(oldDataset, newDataset); newDataset.RecalculateGroupLengths(false); return(newDataset); }
private static DicomDataset Decode( DicomDataset oldDataset, DicomTransferSyntax outSyntax, IDicomCodec codec, DicomCodecParams parameters) { var oldPixelData = DicomPixelData.Create(oldDataset, false); var newDataset = oldDataset.Clone(); newDataset.InternalTransferSyntax = outSyntax; var newPixelData = DicomPixelData.Create(newDataset, true); codec.Decode(oldPixelData, newPixelData, parameters); ProcessOverlays(oldDataset, newDataset); newDataset.RecalculateGroupLengths(false); return(newDataset); }
private DicomDataset Encode(DicomDataset oldDataset, DicomTransferSyntax inSyntax, IDicomCodec codec, DicomCodecParams parameters) { DicomPixelData oldPixelData = DicomPixelData.Create(oldDataset, false); DicomDataset newDataset = oldDataset.Clone(); newDataset.InternalTransferSyntax = codec.TransferSyntax; DicomPixelData newPixelData = DicomPixelData.Create(newDataset, true); codec.Encode(oldPixelData, newPixelData, parameters); if (codec.TransferSyntax.IsLossy && newPixelData.NumberOfFrames > 0) { newDataset.Add(new DicomCodeString(DicomTag.LossyImageCompression, "01")); List<string> methods = new List<string>(); if (newDataset.Contains(DicomTag.LossyImageCompressionMethod)) methods.AddRange(newDataset.Get<string[]>(DicomTag.LossyImageCompressionMethod)); methods.Add(codec.TransferSyntax.LossyCompressionMethod); newDataset.Add(new DicomCodeString(DicomTag.LossyImageCompressionMethod, methods.ToArray())); double oldSize = oldPixelData.GetFrame(0).Size; double newSize = newPixelData.GetFrame(0).Size; string ratio = String.Format("{0:0.000}", oldSize / newSize); newDataset.Add(new DicomDecimalString(DicomTag.LossyImageCompressionRatio, ratio)); } ProcessOverlays(oldDataset, newDataset); newDataset.RecalculateGroupLengths(false); return newDataset; }
private DicomDataset Decode(DicomDataset oldDataset, DicomTransferSyntax outSyntax, IDicomCodec codec, DicomCodecParams parameters) { DicomPixelData oldPixelData = DicomPixelData.Create(oldDataset, false); DicomDataset newDataset = oldDataset.Clone(); newDataset.InternalTransferSyntax = outSyntax; DicomPixelData newPixelData = DicomPixelData.Create(newDataset, true); codec.Decode(oldPixelData, newPixelData, parameters); ProcessOverlays(oldDataset, newDataset); newDataset.RecalculateGroupLengths(false); return newDataset; }
public static DicomFile ChangeTransferSyntax(this DicomFile file, DicomTransferSyntax syntax, DicomCodecParams parameters = null) { DicomTranscoder transcoder = new DicomTranscoder(file.FileMetaInfo.TransferSyntax, syntax); transcoder.InputCodecParams = parameters; transcoder.OutputCodecParams = parameters; return(transcoder.Transcode(file)); }
public static DicomDataset ChangeTransferSyntax(this DicomDataset dataset, DicomTransferSyntax syntax, DicomCodecParams parameters = null) { DicomTranscoder transcoder = new DicomTranscoder(dataset.InternalTransferSyntax, syntax); transcoder.InputCodecParams = parameters; transcoder.OutputCodecParams = parameters; return(transcoder.Transcode(dataset)); }
private void ChangeSyntax(DicomTransferSyntax syntax, DicomCodecParams param = null) { var file = _file.ChangeTransferSyntax(syntax, param); OpenFile(file); }
public static DicomDataset ChangeTransferSyntax(this DicomDataset dataset, DicomTransferSyntax syntax, DicomCodecParams parameters = null) { DicomTranscoder transcoder = new DicomTranscoder(dataset.InternalTransferSyntax, syntax); transcoder.InputCodecParams = parameters; transcoder.OutputCodecParams = parameters; return transcoder.Transcode(dataset); }
public abstract void Decode(DicomPixelData oldPixelData, DicomPixelData newPixelData, DicomCodecParams parameters);
public static DicomFile ChangeTransferSyntax(this DicomFile file, DicomTransferSyntax syntax, DicomCodecParams parameters = null) { DicomTranscoder transcoder = new DicomTranscoder(file.FileMetaInfo.TransferSyntax, syntax); transcoder.InputCodecParams = parameters; transcoder.OutputCodecParams = parameters; return transcoder.Transcode(file); }
private DicomDataset Encode(DicomDataset oldDataset, DicomTransferSyntax inSyntax, IDicomCodec codec, DicomCodecParams parameters) { DicomPixelData oldPixelData = DicomPixelData.Create(oldDataset, false); DicomDataset newDataset = oldDataset.Clone(); newDataset.InternalTransferSyntax = codec.TransferSyntax; DicomPixelData newPixelData = DicomPixelData.Create(newDataset, true); codec.Encode(oldPixelData, newPixelData, parameters); if (codec.TransferSyntax.IsLossy && newPixelData.NumberOfFrames > 0) { newDataset.Add(new DicomCodeString(DicomTag.LossyImageCompression, "01")); List <string> methods = new List <string>(); if (newDataset.Contains(DicomTag.LossyImageCompressionMethod)) { methods.AddRange(newDataset.Get <string[]>(DicomTag.LossyImageCompressionMethod)); } methods.Add(codec.TransferSyntax.LossyCompressionMethod); newDataset.Add(new DicomCodeString(DicomTag.LossyImageCompressionMethod, methods.ToArray())); double oldSize = oldPixelData.GetFrame(0).Size; double newSize = newPixelData.GetFrame(0).Size; string ratio = String.Format("{0:0.000}", oldSize / newSize); newDataset.Add(new DicomDecimalString(DicomTag.LossyImageCompressionRatio, ratio)); } ProcessOverlays(oldDataset, newDataset); newDataset.RecalculateGroupLengths(false); return(newDataset); }
public abstract void Encode(DicomPixelData oldPixelData, DicomPixelData newPixelData, DicomCodecParams parameters);
private DicomDataset Decode(DicomDataset oldDataset, DicomTransferSyntax outSyntax, IDicomCodec codec, DicomCodecParams parameters) { DicomPixelData oldPixelData = DicomPixelData.Create(oldDataset, false); DicomDataset newDataset = oldDataset.Clone(); newDataset.InternalTransferSyntax = outSyntax; DicomPixelData newPixelData = DicomPixelData.Create(newDataset, true); codec.Decode(oldPixelData, newPixelData, parameters); newDataset.RecalculateGroupLengths(false); return(newDataset); }