public static GrayscaleRenderOptions FromMinMax(DicomDataset dataset)
{
var bits = BitDepth.FromDataset(dataset);
var options = new GrayscaleRenderOptions(bits);
options.RescaleSlope = dataset.Get <double>(DicomTag.RescaleSlope, 1.0);
options.RescaleIntercept = dataset.Get <double>(DicomTag.RescaleIntercept, 0.0);
int padding = dataset.Get <int>(DicomTag.PixelPaddingValue, 0, Int32.MinValue);
var transcoder = new DicomTranscoder(dataset.InternalTransferSyntax, DicomTransferSyntax.ExplicitVRLittleEndian);
var pixels = transcoder.DecodePixelData(dataset, 0);
var range = pixels.GetMinMax(padding);
if (range.Minimum < bits.MinimumValue || range.Minimum == Double.MaxValue)
{
range.Minimum = bits.MinimumValue;
}
if (range.Maximum > bits.MaximumValue || range.Maximum == Double.MinValue)
{
range.Maximum = bits.MaximumValue;
}
options.WindowWidth = Math.Abs(range.Maximum - range.Minimum);
options.WindowCenter = range.Minimum + (options.WindowWidth / 2.0);
options.VOILUTFunction = dataset.Get <string>(DicomTag.VOILUTFunction, "LINEAR");
options.Monochrome1 = dataset.Get <PhotometricInterpretation>(DicomTag.PhotometricInterpretation) == PhotometricInterpretation.Monochrome1;
return(options);
}
public static GrayscaleRenderOptions FromHistogram(DicomDataset dataset, int percent = 90)
{
var bits = BitDepth.FromDataset(dataset);
var options = new GrayscaleRenderOptions(bits);
options.RescaleSlope = dataset.Get <double>(DicomTag.RescaleSlope, 1.0);
options.RescaleIntercept = dataset.Get <double>(DicomTag.RescaleIntercept, 0.0);
var transcoder = new DicomTranscoder(dataset.InternalTransferSyntax, DicomTransferSyntax.ExplicitVRLittleEndian);
var pixels = transcoder.DecodePixelData(dataset, 0);
var histogram = pixels.GetHistogram(0);
int padding = dataset.Get <int>(DicomTag.PixelPaddingValue, 0, Int32.MinValue);
if (padding != Int32.MinValue)
{
histogram.Clear(padding);
}
histogram.ApplyWindow(percent);
options.WindowWidth = histogram.WindowEnd - histogram.WindowStart;
options.WindowCenter = histogram.WindowStart + (options.WindowWidth / 2.0);
options.VOILUTFunction = dataset.Get <string>(DicomTag.VOILUTFunction, "LINEAR");
options.Monochrome1 = dataset.Get <PhotometricInterpretation>(DicomTag.PhotometricInterpretation) == PhotometricInterpretation.Monochrome1;
return(options);
}
public static double[] GetZValues(DicomDataset doseData)
//This method gives back a double array with elements corresponding to the z-values for the doseMatrix 3rd dimension.
{
double[] offsetVector = doseData.Get <double[]>(DicomTag.GridFrameOffsetVector);
double[] doseCorner = doseData.Get <double[]>(DicomTag.ImagePositionPatient);
//If first element starts with a 0, its a relative offset. if it starts with non-zero, it is patient coordinate system values
if (offsetVector[0] != 0)
{
for (int i = 0; i < offsetVector.Length; i++)
{
offsetVector[i] -= offsetVector[0];
}
}
double[] zValues = new double[offsetVector.Length];
for (int i = 0; i < offsetVector.Length; i++)
{
zValues[i] = offsetVector[i] + doseCorner[2];
}
//Now flip if sorted by descending z.
if (zValues[1] - zValues[0] < 0)
{
zValues = DataConversion.ReverseArray(zValues);
}
return(zValues);
}
/// <summary>
/// Create grayscale render options based on specified image pixel values.
/// </summary>
/// <param name="dataset">DICOM dataset from which render options should be obtained.</param>
/// <returns>Grayscale render options based on specified image pixel values.</returns>
public static GrayscaleRenderOptions FromImagePixelValueTags(DicomDataset dataset)
{
var bits = BitDepth.FromDataset(dataset);
var options = new GrayscaleRenderOptions(bits);
options.RescaleSlope = dataset.Get <double>(DicomTag.RescaleSlope, 1.0);
options.RescaleIntercept = dataset.Get <double>(DicomTag.RescaleIntercept, 0.0);
int smallValue = dataset.Get <int>(DicomTag.SmallestImagePixelValue);
int largeValue = dataset.Get <int>(DicomTag.LargestImagePixelValue);
if (smallValue >= largeValue)
{
throw new DicomImagingException(
string.Format("Smallest Image Pixel Value ({0}) > Largest Value ({1})", smallValue, largeValue));
}
options.WindowWidth = Math.Abs(largeValue - smallValue);
options.WindowCenter = (largeValue + smallValue) / 2.0;
options.VOILUTFunction = dataset.Get <string>(DicomTag.VOILUTFunction, "LINEAR");
options.ColorMap = GetColorMap(dataset);
return(options);
}
/// <summary>
/// Create <see cref="GrayscaleRenderOptions"/> from <paramref name="dataset"/> and populate the options properties with values:
/// Bit Depth
/// Rescale Slope
/// Rescale Intercept
/// Window Width
/// Window Center
/// </summary>
/// <param name="dataset">Dataset to extract <see cref="GrayscaleRenderOptions"/> from</param>
/// <returns>New grayscale render options instance</returns>
public static GrayscaleRenderOptions FromDataset(DicomDataset dataset)
{
var bits = BitDepth.FromDataset(dataset);
var options = new GrayscaleRenderOptions(bits);
options.RescaleSlope = dataset.Get <double>(DicomTag.RescaleSlope, 1.0);
options.RescaleIntercept = dataset.Get <double>(DicomTag.RescaleIntercept, 0.0);
if (dataset.Contains(DicomTag.WindowWidth) && dataset.Get <double>(DicomTag.WindowWidth) != 0.0)
{
//If dataset contains WindowWidth and WindowCenter valid attributes used initially for the grayscale options
return(FromWindowLevel(dataset));
}
else if (dataset.Contains(DicomTag.SmallestImagePixelValue) && dataset.Contains(DicomTag.LargestImagePixelValue))
{
//If dataset contains valid SmallesImagePixelValue and LargesImagePixelValue attributes, use range to calculate
//WindowWidth and WindowCenter
return(FromImagePixelValueTags(dataset));
}
else
{
//If reached here, minimum and maximum pixel values calculated from pixels data to calculate
//WindowWidth and WindowCenter
return(FromMinMax(dataset));
}
options.VOILUTFunction = dataset.Get <string>(DicomTag.VOILUTFunction, "LINEAR");
options.Monochrome1 = dataset.Get <PhotometricInterpretation>(DicomTag.PhotometricInterpretation) == PhotometricInterpretation.Monochrome1;
return(options);
}
public static double[] GetXValues(DicomDataset doseData)
{
int[] orientation = doseData.Get <int[]>(DicomTag.ImageOrientationPatient);
double[] doseCorner = doseData.Get <double[]>(DicomTag.ImagePositionPatient);
int cols = doseData.Get <int>(DicomTag.Columns);
double[] pixelSpacing = doseData.Get <double[]>(DicomTag.PixelSpacing);
double[] xValues = new double[cols];
if ((orientation[3] == 0) && (orientation[4] == 1) && (orientation[5] == 0))
{
for (int i = 0; i < cols; i++)
{
xValues[i] = pixelSpacing[0] * i + doseCorner[0];
}
}
else if ((orientation[3] == 0) && (orientation[4] == -1) && (orientation[5] == 0))
{
for (int i = 0; i < cols; i++)
{
xValues[i] = -pixelSpacing[0] * i + doseCorner[0];
xValues = DataConversion.ReverseArray(xValues);
}
}
else
{
Console.WriteLine("patient orientation error encountered. Terminating.");
Environment.Exit(2);
}
return(xValues);
}
public static double[] GetYValues(DicomDataset doseData)
{
int[] orientation = doseData.Get <int[]>(DicomTag.ImageOrientationPatient);
double[] doseCorner = doseData.Get <double[]>(DicomTag.ImagePositionPatient);
int rows = doseData.Get <int>(DicomTag.Rows);
double[] pixelSpacing = doseData.Get <double[]>(DicomTag.PixelSpacing);
double[] yValues = new double[rows];
if ((orientation[0] == 1) && (orientation[1] == 0) && (orientation[2] == 0))
{
for (int i = 0; i < rows; i++)
{
yValues[i] = pixelSpacing[1] * i + doseCorner[1];
}
}
else if ((orientation[0] == -1) && (orientation[1] == 0) && (orientation[2] == 0))
{
for (int i = 0; i < rows; i++)
{
yValues[i] = -pixelSpacing[1] * i + doseCorner[1];
yValues = DataConversion.ReverseArray(yValues);
}
}
else
{
Console.WriteLine("patient orientation error encountered. Terminating.");
Environment.Exit(2);
}
return(yValues);
}
/// <summary>
/// Create grayscale render options based on pixel data histogram.
/// </summary>
/// <param name="dataset">DICOM dataset from which render options should be obtained.</param>
/// <param name="percent">Percentage of histogram window to include.</param>
/// <returns>Grayscale render options based on pixel data histogram.</returns>
public static GrayscaleRenderOptions FromHistogram(DicomDataset dataset, int percent = 90)
{
var bits = BitDepth.FromDataset(dataset);
var options = new GrayscaleRenderOptions(bits);
options.RescaleSlope = dataset.Get <double>(DicomTag.RescaleSlope, 1.0);
options.RescaleIntercept = dataset.Get <double>(DicomTag.RescaleIntercept, 0.0);
var transcoder = new DicomTranscoder(
dataset.InternalTransferSyntax,
DicomTransferSyntax.ExplicitVRLittleEndian);
var pixels = transcoder.DecodePixelData(dataset, 0);
var histogram = pixels.GetHistogram(0);
int padding = dataset.Get <int>(DicomTag.PixelPaddingValue, 0, Int32.MinValue);
if (padding != Int32.MinValue)
{
histogram.Clear(padding);
}
histogram.ApplyWindow(percent);
var min = histogram.WindowStart * options.RescaleSlope + options.RescaleIntercept;
var max = histogram.WindowEnd * options.RescaleSlope + options.RescaleIntercept;
options.WindowWidth = Math.Abs(max - min);
options.WindowCenter = (max + min) / 2.0;
options.VOILUTFunction = dataset.Get <string>(DicomTag.VOILUTFunction, "LINEAR");
options.ColorMap = GetColorMap(dataset);
return(options);
}
public static BitDepth FromDataset(DicomDataset dataset)
{
var allocated = dataset.Get<ushort>(DicomTag.BitsAllocated);
var stored = dataset.Get<ushort>(DicomTag.BitsStored);
var signed = dataset.Get<PixelRepresentation>(DicomTag.PixelRepresentation) == PixelRepresentation.Signed;
return new BitDepth(allocated, stored, GetHighBit(stored, signed), signed);
}
public DicomFileMetaInformation(DicomDataset dataset)
: this()
{
MediaStorageSOPClassUID = dataset.Get<DicomUID>(DicomTag.SOPClassUID);
MediaStorageSOPInstanceUID = dataset.Get<DicomUID>(DicomTag.SOPInstanceUID);
TransferSyntax = dataset.InternalTransferSyntax;
}
public void BulkDataRead()
{
File.WriteAllText("test.txt", "xxx!");
var path = Path.GetFullPath("test.txt");
var bulkData = new BulkDataUriByteBuffer("file:" + path);
Assert.Throws <InvalidOperationException>(() => bulkData.Data);
Assert.Throws <InvalidOperationException>(() => bulkData.Size);
var target = new DicomDataset {
new DicomOtherWord(DicomTag.PixelData, bulkData)
};
var json = JsonConvert.SerializeObject(target, Formatting.Indented, new JsonDicomConverter());
var reconstituated = JsonConvert.DeserializeObject <DicomDataset>(json, new JsonDicomConverter());
var json2 = JsonConvert.SerializeObject(reconstituated, Formatting.Indented, new JsonDicomConverter());
Assert.Equal(json, json2);
DownloadBulkData(reconstituated.Get <BulkDataUriByteBuffer>(DicomTag.PixelData));
DownloadBulkData(bulkData);
Assert.True(ValueEquals(target, reconstituated));
byte[] expectedPixelData = File.ReadAllBytes("test.txt");
File.Delete("test.txt");
Assert.Equal(target.Get <IByteBuffer>(DicomTag.PixelData).Size, (uint)expectedPixelData.Length);
Assert.True(target.Get <byte[]>(DicomTag.PixelData).SequenceEqual(expectedPixelData));
Assert.Equal(reconstituated.Get <IByteBuffer>(DicomTag.PixelData).Size, (uint)expectedPixelData.Length);
Assert.True(reconstituated.Get <byte[]>(DicomTag.PixelData).SequenceEqual(expectedPixelData));
}
/// <summary>
/// Create new instance of <seealso cref="BitDpeth"/> from input <paramref name="dataset"/>
/// </summary>
/// <param name="dataset">Input dataset to extract bit depth information from</param>
/// <returns>New <seealso cref="BitDepth"/> instance</returns>
public static BitDepth FromDataset(DicomDataset dataset)
{
var allocated = dataset.Get <ushort>(DicomTag.BitsAllocated);
var stored = dataset.Get <ushort>(DicomTag.BitsStored);
var signed = dataset.Get <PixelRepresentation>(DicomTag.PixelRepresentation) == PixelRepresentation.Signed;
return(new BitDepth(allocated, stored, GetHighBit(stored, signed), signed));
}
public DicomDirectoryRecord BuildDirectoryRecords()
{
uint offset = 0;
offset = _dataset.Get <uint>(DicomTag.OffsetOfTheFirstDirectoryRecordOfTheRootDirectoryEntity);
return(ParseDirectoryRecord(offset));
}
/// <summary>
/// Convert the byte data retrieved from DCM file to Image
/// </summary>
/// <param name="imagedata"></param>
/// <returns></returns>
private Bitmap ConvertDCMData2BitImage(DicomFile dcm)
{
DicomFile newDcmFile = null;
if (dcm.FileMetaInfo.TransferSyntax.IsEncapsulated)//if the data is compressed
{
// System.Reflection.Assembly.LoadFrom(Path.Combine(Application.StartupPath,"Dicom.Native64.dll"));
DicomTranscoder.LoadCodecs(Application.StartupPath, "Dicom.Native*.dll");
newDcmFile = dcm.ChangeTransferSyntax(DicomTransferSyntax.ExplicitVRLittleEndian, new DicomJpegLsParams());
}
DicomImage imageDcm = null;
if (newDcmFile != null)
{
imageDcm = new DicomImage(newDcmFile.Dataset);
}
else
{
imageDcm = new DicomImage(dcm.Dataset);
}
DicomDataset dataset = dcm.Dataset;
byte[] fs = imageDcm.PixelData.NumberOfFrames < 2 ? imageDcm.PixelData.GetFrame(0).Data : imageDcm.PixelData.GetFrame(1).Data;
uint size = (uint)Marshal.SizeOf(typeof(short));
uint padding = (uint)fs.Length % size;
uint count = (uint)fs.Length / size;
short[] values = new short[count];
System.Buffer.BlockCopy(fs, 0, values, 0, (int)(fs.Length - padding));
int height = dataset.Get <int>(DicomTag.Rows);
int width = dataset.Get <int>(DicomTag.Columns);
int windowsWidth = (int)dataset.Get <double>(DicomTag.WindowWidth);
int windowsCenter = (int)dataset.Get <double>(DicomTag.WindowCenter);
//if the windowsWidth = 0, the DCM file is not standard type.
if (windowsWidth == 0 || windowsCenter == 0)
{
windowsWidth = values.Max <short>() - values.Min <short>();
windowsCenter = windowsWidth / 2;
}
int low = windowsCenter - windowsWidth / 2;
int high = windowsCenter + windowsWidth / 2;
Bitmap bitmap = new Bitmap(width, height);
for (int i = 0; i < height; ++i)
{
for (int j = 0; j < width; ++j)
{
int r, g, b;
int temp = (int)values[(width - j - 1) * height + i];
int val = temp > high ? 255 : (temp < low ? 0 : ((temp - low) * 255 / windowsWidth));
r = g = b = val;
bitmap.SetPixel(i, width - j - 1, Color.FromArgb(r, g, b));
}
}
return(bitmap);
}
public virtual IObjectId CreateObjectId(DicomDataset dataset)
{
return(new ObjectId( )
{
StudyInstanceUID = dataset.Get <string>(DicomTag.StudyInstanceUID, 0, ""),
SeriesInstanceUID = dataset.Get <string>(DicomTag.SeriesInstanceUID, 0, ""),
SOPInstanceUID = dataset.Get <string>(DicomTag.SOPInstanceUID, 0, "")
});
}
public void Old_Send_PrivateTags_DataSufficientlyTransported()
{
var port = Ports.GetNext();
using (DicomServer.Create <SimpleCStoreProvider>(port))
{
DicomDataset command = null, requestDataset = null, responseDataset = null;
var request = new DicomCStoreRequest(new DicomDataset
{
{ DicomTag.CommandField, (ushort)DicomCommandField.CStoreRequest },
{ DicomTag.AffectedSOPClassUID, DicomUID.CTImageStorage },
{ DicomTag.MessageID, (ushort)1 },
{ DicomTag.AffectedSOPInstanceUID, "1.2.3" },
});
var privateCreator = DicomDictionary.Default.GetPrivateCreator("Testing");
var privTag1 = new DicomTag(4013, 0x008, privateCreator);
var privTag2 = new DicomTag(4013, 0x009, privateCreator);
DicomDictionary.Default.Add(new DicomDictionaryEntry(privTag1, "testTag1", "testKey1", DicomVM.VM_1, false, DicomVR.CS));
DicomDictionary.Default.Add(new DicomDictionaryEntry(privTag2, "testTag2", "testKey2", DicomVM.VM_1, false, DicomVR.CS));
request.Dataset = new DicomDataset();
request.Dataset.Add(DicomTag.Modality, "CT");
request.Dataset.Add(privTag1, "TESTA");
request.Dataset.Add(new DicomCodeString(privTag2, "TESTB"));
//{
// { DicomTag.Modality, "CT" },
// new DicomCodeString(privTag1, "test1"),
// { privTag2, "test2" },
//};
request.OnResponseReceived = (req, res) =>
{
command = req.Command;
requestDataset = req.Dataset;
responseDataset = res.Dataset;
};
var client = new DicomClient();
client.AddRequest(request);
client.Send("127.0.0.1", port, false, "SCU", "ANY-SCP");
Assert.Equal((ushort)1, command.Get <ushort>(DicomTag.CommandField));
Assert.Equal("CT", requestDataset.Get <string>(DicomTag.Modality));
Assert.Equal("TESTB", requestDataset.Get <string>(privTag2, null));
Assert.Equal("TESTA", requestDataset.Get <string>(privTag1, null));
Assert.Equal("CT", responseDataset.Get <string>(DicomTag.Modality));
// Assert.Equal("test1", responseDataset.Get<DicomCodeString>(privTag1).Get<string>());
Assert.Equal("TESTB", responseDataset.Get <string>(privTag2, -1, null));
Assert.Equal("TESTA", responseDataset.Get <string>(privTag1, null));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DicomFileMetaInformation"/> class.
/// </summary>
/// <param name="dataset">
/// The data set for which file meta information is required.
/// </param>
public DicomFileMetaInformation(DicomDataset dataset)
{
this.Version = new byte[] { 0x00, 0x01 };
this.MediaStorageSOPClassUID = dataset.Get<DicomUID>(DicomTag.SOPClassUID);
this.MediaStorageSOPInstanceUID = dataset.Get<DicomUID>(DicomTag.SOPInstanceUID);
this.TransferSyntax = dataset.InternalTransferSyntax;
this.ImplementationClassUID = DicomImplementation.ClassUID;
this.ImplementationVersionName = DicomImplementation.Version;
this.SourceApplicationEntityTitle = CreateSourceApplicationEntityTitle();
}
private static bool tryGetImageDateTime(DicomTag dateTag, DicomTag timeTag, DicomDataset dataset,
ref DateTime imageDate, ref DateTime imageTime)
{
var dateValue = dataset.Get<DateTime>(dateTag);
var result = dateValue > DateTime.MinValue;
if (result)
{
imageDate = dateValue;
imageTime = dataset.Get<DateTime>(timeTag);
}
return result;
}
/// <summary>
/// Create <see cref="GrayscaleRenderOptions"/> from <paramref name="dataset"/> and populate the options properties with values:
/// Bit Depth
/// Rescale Slope
/// Rescale Intercept
/// Window Width
/// Window Center
/// </summary>
/// <param name="dataset">Dataset to extract <see cref="GrayscaleRenderOptions"/> from</param>
/// <returns>New grayscale render options instance</returns>
public static GrayscaleRenderOptions FromDataset(DicomDataset dataset)
{
var bits = BitDepth.FromDataset(dataset);
var options = new GrayscaleRenderOptions(bits);
options.RescaleSlope = dataset.Get <double>(DicomTag.RescaleSlope, 1.0);
options.RescaleIntercept = dataset.Get <double>(DicomTag.RescaleIntercept, 0.0);
if (dataset.Contains(DicomTag.WindowWidth) && dataset.Get <double>(DicomTag.WindowWidth) != 0.0)
{
//If dataset contains WindowWidth and WindowCenter valid attributes used initially for the grayscale options
options.WindowWidth = dataset.Get <double>(DicomTag.WindowWidth);
options.WindowCenter = dataset.Get <double>(DicomTag.WindowCenter);
}
else if (dataset.Contains(DicomTag.SmallestImagePixelValue) && dataset.Contains(DicomTag.LargestImagePixelValue))
{
//If dataset contains valid SmallesImagePixelValue and LargesImagePixelValue attributes, use range to calculage
//WindowWidth and WindowCenter
int smallValue = dataset.Get <int>(DicomTag.SmallestImagePixelValue, 0);
int largeValue = dataset.Get <int>(DicomTag.LargestImagePixelValue, 0);
largeValue = (int)((largeValue * options.RescaleSlope) + options.RescaleIntercept);
smallValue = (int)((smallValue * options.RescaleSlope) + options.RescaleIntercept);
if (smallValue != 0 || largeValue != 0)
{
options.WindowWidth = Math.Abs(largeValue - smallValue);
options.WindowCenter = (largeValue + smallValue) / 2.0;
}
}
else
{
//If reached here, minimum and maximum pixel values calculated from pixels data to calculate
//WindowWidth and WindowCenter
int padding = dataset.Get <int>(DicomTag.PixelPaddingValue, 0, bits.MinimumValue);
var pixelData = DicomPixelData.Create(dataset);
var pixels = PixelDataFactory.Create(pixelData, 0);
var range = pixels.GetMinMax(padding);
range.Maximum = (int)((range.Maximum * options.RescaleSlope) + options.RescaleIntercept);
range.Minimum = (int)((range.Minimum * options.RescaleSlope) + options.RescaleIntercept);
options.WindowWidth = Math.Abs(range.Maximum - range.Minimum);
options.WindowCenter = (range.Maximum + range.Minimum) / 2.0;
}
options.VOILUTFunction = dataset.Get <string>(DicomTag.VOILUTFunction, "LINEAR");
options.Monochrome1 = dataset.Get <PhotometricInterpretation>(DicomTag.PhotometricInterpretation) == PhotometricInterpretation.Monochrome1;
return(options);
}
/// <summary>
/// A factory method to initialize new instance of <seealso cref="DicomPixelData"/> implementation either
/// <seealso cref="OtherWordPixelData"/>, <seealso cref="OtherBytePixelData"/>, or <seealso cref="EncapsulatedPixelData"/>
/// </summary>
/// <param name="dataset">Source DICOM Dataset</param>
/// <param name="newPixelData">true if new <seealso cref="DicomPixelData"/>will be created for current dataset,
/// false to read <seealso cref="DicomPixelData"/> from <paramref name="dataset"/>.
/// Default is false (read)</param>
/// <returns>New instance of DicomPixelData</returns>
public static DicomPixelData Create(DicomDataset dataset, bool newPixelData = false)
{
var syntax = dataset.InternalTransferSyntax;
if (newPixelData)
{
if (syntax == DicomTransferSyntax.ImplicitVRLittleEndian)
{
return(new OtherWordPixelData(dataset, true));
}
if (syntax.IsEncapsulated)
{
return(new EncapsulatedPixelData(dataset, true));
}
if (dataset.Get <ushort>(DicomTag.BitsAllocated) == 16)
{
return(new OtherWordPixelData(dataset, true));
}
else
{
return(new OtherBytePixelData(dataset, true));
}
}
else
{
var item = dataset.Get <DicomItem>(DicomTag.PixelData);
if (item == null)
{
throw new DicomImagingException("DICOM dataset is missing pixel data element.");
}
if (item is DicomOtherByte)
{
return(new OtherBytePixelData(dataset, false));
}
if (item is DicomOtherWord)
{
return(new OtherWordPixelData(dataset, false));
}
if (item is DicomOtherByteFragment || item is DicomOtherWordFragment)
{
return(new EncapsulatedPixelData(dataset, false));
}
throw new DicomImagingException("Unexpected or unhandled pixel data element type: {0}", item.GetType());
}
}
public DicomFileMetaInformation(DicomDataset dataset)
: base()
{
Version = new byte[] { 0x00, 0x01 };
MediaStorageSOPClassUID = dataset.Get<DicomUID>(DicomTag.SOPClassUID);
MediaStorageSOPInstanceUID = dataset.Get<DicomUID>(DicomTag.SOPInstanceUID);
TransferSyntax = dataset.InternalTransferSyntax;
ImplementationClassUID = DicomImplementation.ClassUID;
ImplementationVersionName = DicomImplementation.Version;
var machine = Environment.MachineName;
if (machine.Length > 16)
machine = machine.Substring(0, 16);
SourceApplicationEntityTitle = machine;
}
public static GrayscaleRenderOptions FromDataset(DicomDataset dataset)
{
var bits = BitDepth.FromDataset(dataset);
var options = new GrayscaleRenderOptions(bits);
options.RescaleSlope = dataset.Get <double>(DicomTag.RescaleSlope, 1.0);
options.RescaleIntercept = dataset.Get <double>(DicomTag.RescaleIntercept, 0.0);
if (dataset.Contains(DicomTag.WindowWidth))
{
options.WindowWidth = dataset.Get <double>(DicomTag.WindowWidth);
options.WindowCenter = dataset.Get <double>(DicomTag.WindowCenter);
}
options.Monochrome1 = dataset.Get <PhotometricInterpretation>(DicomTag.PhotometricInterpretation) == PhotometricInterpretation.Monochrome1;
return(options);
}
public void Add_OtherDoubleElementWithMultipleDoubles_Succeeds()
{
var dataset = new DicomDataset();
dataset.Add(DicomTag.DoubleFloatPixelData, 3.45, 6.78, 9.01);
Assert.IsType(typeof(DicomOtherDouble), dataset.First());
Assert.Equal(3, dataset.Get<double[]>(DicomTag.DoubleFloatPixelData).Length);
}
public void SerializeAndDeserializePrivateTags()
{
var privCreatorDictEntry = new DicomDictionaryEntry(new DicomTag(0x0011, 0x0010), "Private Creator", "PrivateCreator", DicomVM.VM_1, false, DicomVR.LO);
DicomDictionary.Default.Add(privCreatorDictEntry);
DicomPrivateCreator privateCreator1 = DicomDictionary.Default.GetPrivateCreator("TESTCREATOR1");
DicomDictionary privDict1 = DicomDictionary.Default[privateCreator1];
var dictEntry = new DicomDictionaryEntry(DicomMaskedTag.Parse("0011", "xx01"), "TestPrivTagName", "TestPrivTagKeyword", DicomVM.VM_1, false, DicomVR.CS);
privDict1.Add(dictEntry);
var ds = new DicomDataset();
ds.Add(dictEntry.Tag, "VAL1");
ds.Add(DicomTag.SOPClassUID, DicomUID.CTImageStorage);
ds.Add(DicomTag.SOPInstanceUID, "2.25.123");
Assert.Equal(DicomVR.CS, ds.Get<DicomVR>(dictEntry.Tag));
var bytes = SerializeDicom_(ds);
File.OpenWrite("C:\\Temp\\x.dcm").Write(bytes, 0, bytes.Length);
var ds2 = ParseDicom_(bytes);
Assert.Equal(DicomVR.CS, ds2.Get<DicomVR>(dictEntry.Tag));
}
public void Add_UniversalResourceElement_Succeeds()
{
var dataset = new DicomDataset();
dataset.Add(DicomTag.URNCodeValue, "abc");
Assert.IsType(typeof(DicomUniversalResource), dataset.First());
Assert.Equal("abc", dataset.Get<string>(DicomTag.URNCodeValue));
}
public static GrayscaleRenderOptions FromBitRange(DicomDataset dataset)
{
var bits = BitDepth.FromDataset(dataset);
var options = new GrayscaleRenderOptions(bits);
options.RescaleSlope = dataset.Get <double>(DicomTag.RescaleSlope, 1.0);
options.RescaleIntercept = dataset.Get <double>(DicomTag.RescaleIntercept, 0.0);
options.WindowWidth = bits.MaximumValue - bits.MinimumValue;
options.WindowCenter = bits.MinimumValue + (options.WindowWidth / 2.0);
options.VOILUTFunction = dataset.Get <string>(DicomTag.VOILUTFunction, "LINEAR");
options.Monochrome1 = dataset.Get <PhotometricInterpretation>(DicomTag.PhotometricInterpretation) == PhotometricInterpretation.Monochrome1;
return(options);
}
/// <summary>
/// Get grayscale color map based on Photometric Interpretation.
/// </summary>
/// <param name="dataset">DICOM dataset from which Photometric Interpretation should be obtained.</param>
/// <returns>Color map associated with the identified Photometric Interpretation.</returns>
private static Color32[] GetColorMap(DicomDataset dataset)
{
return(dataset.Get <PhotometricInterpretation>(DicomTag.PhotometricInterpretation)
== PhotometricInterpretation.Monochrome1
? ColorTable.Monochrome1
: ColorTable.Monochrome2);
}
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);
}
/// <summary>
/// Create grayscale render options based on window level data.
/// </summary>
/// <param name="dataset">DICOM dataset from which render options should be obtained.</param>
/// <returns>Grayscale render options based on window level data.</returns>
public static GrayscaleRenderOptions FromWindowLevel(DicomDataset dataset)
{
var bits = BitDepth.FromDataset(dataset);
var options = new GrayscaleRenderOptions(bits);
options.RescaleSlope = dataset.Get <double>(DicomTag.RescaleSlope, 1.0);
options.RescaleIntercept = dataset.Get <double>(DicomTag.RescaleIntercept, 0.0);
options.WindowWidth = dataset.Get <double>(DicomTag.WindowWidth);
options.WindowCenter = dataset.Get <double>(DicomTag.WindowCenter);
options.VOILUTFunction = dataset.Get <string>(DicomTag.VOILUTFunction, "LINEAR");
options.ColorMap = GetColorMap(dataset);
return(options);
}
public void SerializeAndDeserializePrivateTags()
{
var privCreatorDictEntry = new DicomDictionaryEntry(new DicomTag(0x0011, 0x0010), "Private Creator", "PrivateCreator", DicomVM.VM_1, false, DicomVR.LO);
DicomDictionary.Default.Add(privCreatorDictEntry);
DicomPrivateCreator privateCreator1 = DicomDictionary.Default.GetPrivateCreator("TESTCREATOR1");
DicomDictionary privDict1 = DicomDictionary.Default[privateCreator1];
var dictEntry = new DicomDictionaryEntry(DicomMaskedTag.Parse("0011", "xx01"), "TestPrivTagName", "TestPrivTagKeyword", DicomVM.VM_1, false, DicomVR.CS);
privDict1.Add(dictEntry);
var ds = new DicomDataset();
ds.Add(dictEntry.Tag, "VAL1");
ds.Add(DicomTag.SOPClassUID, DicomUID.CTImageStorage);
ds.Add(DicomTag.SOPInstanceUID, "2.25.123");
Assert.Equal(DicomVR.CS, ds.Get <DicomVR>(dictEntry.Tag));
var bytes = SerializeDicom_(ds);
File.OpenWrite("C:\\Temp\\x.dcm").Write(bytes, 0, bytes.Length);
var ds2 = ParseDicom_(bytes);
Assert.Equal(DicomVR.CS, ds2.Get <DicomVR>(dictEntry.Tag));
}
private Dictionary <string, object> getTagByList(DicomDataset dicomDataSet, Dictionary <DicomTag, string> tagClassList)
{
Dictionary <string, object> dict = new Dictionary <string, object>();
foreach (var tagclass in tagClassList)
{
try
{
string key = Convert.ToString(tagclass.Key.Group, 16).PadLeft(4, '0').ToUpper() + Convert.ToString(tagclass.Key.Element, 16).PadLeft(4, '0').ToUpper();
if (!dict.ContainsKey(key))
{
dict.Add(key, getMapByTag(tagclass.Value, dicomDataSet.Get <string>(tagclass.Key)));
}
else
{
MessageBox.Show(tagclass.Key.Element.ToString());
}
}
catch (Exception e)
{
MessageBox.Show(e.StackTrace.ToString());
}
}
return(dict);
}
public void Add_UnlimitedCharactersElementWithMultipleStrings_Succeeds()
{
var dataset = new DicomDataset();
dataset.Add(DicomTag.LongCodeValue, "a", "b", "c");
Assert.IsType(typeof(DicomUnlimitedCharacters), dataset.First());
Assert.Equal("c", dataset.Get<string>(DicomTag.LongCodeValue, 2));
}
/// <summary>
/// Gets all overlays in a DICOM dataset.
/// </summary>
/// <param name="ds">Dataset</param>
/// <returns>Array of overlays</returns>
public static DicomOverlayData[] FromDataset(DicomDataset ds)
{
var groups = new List <ushort>();
groups.AddRange(
ds.Where(x => x.Tag.Group >= 0x6000 && x.Tag.Group <= 0x60FF && x.Tag.Element == 0x0010)
.Select(x => x.Tag.Group));
var overlays = new List <DicomOverlayData>();
foreach (var group in groups)
{
// ensure that 6000 group is actually an overlay group
if (ds.Get <DicomElement>(new DicomTag(group, 0x0010)).ValueRepresentation != DicomVR.US)
{
continue;
}
try
{
DicomOverlayData overlay = new DicomOverlayData(ds, group);
overlays.Add(overlay);
}
catch
{
// bail out if not an overlay group
}
}
return(overlays.ToArray());
}
public async Task Send_SingleRequest_DataSufficientlyTransported()
{
int port = Ports.GetNext();
using (DicomServer.Create <SimpleCStoreProvider>(port))
{
DicomDataset command = null, dataset = null;
var request = new DicomCStoreRequest(@".\Test Data\CT1_J2KI");
request.OnResponseReceived = (req, res) =>
{
command = request.Command;
dataset = request.Dataset;
};
var client = new Network.Client.DicomClient("127.0.0.1", port, false, "SCU", "ANY-SCP");
await client.AddRequestAsync(request).ConfigureAwait(false);
await client.SendAsync().ConfigureAwait(false);
var commandField = command.Get <ushort>(DicomTag.CommandField);
Assert.Equal((ushort)1, commandField);
var modality = dataset.Get <string>(DicomTag.Modality);
Assert.Equal("CT", modality);
}
}
private static void ProcessOverlays(DicomDataset input, DicomDataset output)
{
var overlays = DicomOverlayData.FromDataset(input.InternalTransferSyntax.IsEncapsulated ? output : input);
foreach (var overlay in overlays)
{
var dataTag = new DicomTag(overlay.Group, DicomTag.OverlayData.Element);
// Don't run conversion on non-embedded overlays.
if (output.Contains(dataTag))
{
continue;
}
// If embedded overlay, Overlay Bits Allocated should equal Bits Allocated (#110).
var bitsAlloc = output.Get(DicomTag.BitsAllocated, (ushort)0);
output.AddOrUpdate(new DicomTag(overlay.Group, DicomTag.OverlayBitsAllocated.Element), bitsAlloc);
var data = overlay.Data;
if (output.InternalTransferSyntax.IsExplicitVR)
{
output.AddOrUpdate(new DicomOtherByte(dataTag, data));
}
else
{
output.AddOrUpdate(new DicomOtherWord(dataTag, data));
}
}
}
private void CreateSequence(List <string> elements, int currentElementIndex, DicomDataset dicomRequest, string value)
{
uint tag = GetTagValue(elements[currentElementIndex]);
var dicEntry = DicomDictionary.Default[tag];
DicomSequence sequence;
DicomDataset item;
dicomRequest.AddOrUpdate(new DicomSequence(dicEntry.Tag));
sequence = dicomRequest.Get <DicomSequence>(dicEntry.Tag);
item = new DicomDataset( );
sequence.Items.Add(item);
for (int index = (currentElementIndex + 1); index < elements.Count; index++)
{
tag = GetTagValue(elements[index]);
dicEntry = DicomDictionary.Default[tag];
if (dicEntry.ValueRepresentations.Contains(DicomVR.SQ))
{
CreateSequence(elements, index, item, value);
break;
}
else
{
item.AddOrUpdate <string> (tag, value);
}
}
}
public void GetPrivateTagsChangesNothingWhenPresent()
{
DicomPrivateCreator privateCreator = DicomDictionary.Default.GetPrivateCreator("TESTCREATOR");
DicomDictionary privDict = DicomDictionary.Default[privateCreator];
var privTag = new DicomDictionaryEntry(DicomMaskedTag.Parse("0011", "xx10"), "TestPrivTagName", "TestPrivTagKeyword", DicomVM.VM_1, false, DicomVR.DT);
privDict.Add(privTag);
var dataSet = new DicomDataset
{
{ DicomTag.SOPInstanceUID, "2.999.1241" },
{ DicomTag.SOPClassUID, "2.999.1242" },
{ privTag.Tag, "19700101123456" }
};
var dataBefore = SerializeDicom_(dataSet);
var val = dataSet.Get <string>(privTag.Tag);
var dataAfter = SerializeDicom_(dataSet);
Assert.Equal(dataBefore, dataAfter);
Assert.Equal(val, "19700101123456");
}
public void DicomDateTime_FractionalSecondsAndTimezone_SupportedFormat()
{
var dt = DateTime.Now.ToString("yyyyMMddHHmmss.ffffffzzz");
var dataset = new DicomDataset { new DicomDateTime(DicomTag.ScheduledProcedureStepStartDateTime, dt) };
var exception = Record.Exception(() => dataset.Get<DicomDateRange>(DicomTag.ScheduledProcedureStepStartDateTime));
Assert.Null(exception);
}
//Writes the general set of parameters for every patient to the crosswalk
//public void addParametersToCrosswalk(List<string> generalParameters)
//{
//using (StreamWriter sw = File.AppendText(path))
//{
//sw.Write(crosswalkFormatter("ID:", 10) + "| ");
//foreach (string item in generalParameters)
//{
//sw.Write(crosswalkFormatter(item + ":", 20) + "| ");
//}
//}
//}
//Writes the patient's information to the correct location in the crosswalk table
public void addPatientInfo(List <DicomTag> tags, DicomDataset dataSet, string name)
{
string patientID = getID(name);
if (!File.Exists(path))
{
MessageBox.Show("Crosswalk table is being created");
using (StreamWriter sw = new StreamWriter(path, true))
{
sw.Write(crosswalkFormatter("ID: " + patientID, 10) + " | ");
foreach (DicomTag tag in tags)
{
sw.Write(tag.DictionaryEntry.Keyword + ": " + dataSet.Get <string>(tag) + "| ");
}
sw.WriteLine();
}
}
else if (File.Exists(path))
{
var fileread = File.ReadAllText(path);
//If the patient already exists in the crosswalk, don't add them again
if (fileread.Contains(patientID))
{
MessageBox.Show("Patient already in crosswalk!");
}
else
{
using (StreamWriter sw = new StreamWriter(path, true))
{
sw.Write(crosswalkFormatter("ID: " + patientID, 10) + " | ");
foreach (DicomTag tag in tags)
{
sw.Write(tag.DictionaryEntry.Keyword + ": " + dataSet.Get <string>(tag) + "| ");
}
sw.WriteLine();
}
MessageBox.Show("Patient added to crosswalk");
}
}
}
public void Add_OtherDoubleElementWithMultipleDoubles_Succeeds()
{
var tag = DicomTag.DoubleFloatPixelData;
var dataset = new DicomDataset();
dataset.Add(tag, 3.45, 6.78, 9.01);
Assert.IsType<DicomOtherDouble>(dataset.First(item => item.Tag.Equals(tag)));
Assert.Equal(3, dataset.Get<double[]>(tag).Length);
}
public void Add_UnlimitedCharactersElementWithMultipleStrings_Succeeds()
{
var tag = DicomTag.LongCodeValue;
var dataset = new DicomDataset();
dataset.Add(tag, "a", "b", "c");
Assert.IsType<DicomUnlimitedCharacters>(dataset.First(item => item.Tag.Equals(tag)));
Assert.Equal("c", dataset.Get<string>(tag, 2));
}
public void Add_UniversalResourceElement_Succeeds()
{
var tag = DicomTag.URNCodeValue;
var dataset = new DicomDataset();
dataset.Add(tag, "abc");
Assert.IsType<DicomUniversalResource>(dataset.First(item => item.Tag.Equals(tag)));
Assert.Equal("abc", dataset.Get<string>(tag));
}
public static GrayscaleRenderOptions FromDataset(DicomDataset dataset)
{
var bits = BitDepth.FromDataset(dataset);
var options = new GrayscaleRenderOptions(bits);
options.RescaleSlope = dataset.Get<double>(DicomTag.RescaleSlope, 1.0);
options.RescaleIntercept = dataset.Get<double>(DicomTag.RescaleIntercept, 0.0);
if (dataset.Contains(DicomTag.WindowWidth) && dataset.Get<double>(DicomTag.WindowWidth) != 0.0) {
options.WindowWidth = dataset.Get<double>(DicomTag.WindowWidth);
options.WindowCenter = dataset.Get<double>(DicomTag.WindowCenter);
} else if (dataset.Contains(DicomTag.SmallestImagePixelValue) && dataset.Contains(DicomTag.LargestImagePixelValue)) {
var smallElement = dataset.Get<DicomElement>(DicomTag.SmallestImagePixelValue);
var largeElement = dataset.Get<DicomElement>(DicomTag.LargestImagePixelValue);
int smallValue = 0;
int largeValue = 0;
if (smallElement.ValueRepresentation == DicomVR.US) {
smallValue = smallElement.Get<ushort>(0);
largeValue = smallElement.Get<ushort>(0);
} else {
smallValue = smallElement.Get<short>(0);
largeValue = smallElement.Get<short>(0);
}
options.WindowWidth = largeValue - smallValue;
options.WindowCenter = (largeValue + smallValue) / 2.0;
}
options.Monochrome1 = dataset.Get<PhotometricInterpretation>(DicomTag.PhotometricInterpretation) == PhotometricInterpretation.Monochrome1;
return options;
}
public static void SaveImage(DicomDataset dataset)
{
var studyUid = dataset.Get <string>(DicomTag.StudyInstanceUID);
var instUid = dataset.Get <string>(DicomTag.SOPInstanceUID);
var path = Path.GetFullPath(Program.StoragePath);
path = Path.Combine(path, studyUid);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
path = Path.Combine(path, instUid) + ".dcm";
new DicomFile(dataset).Save(path);
}
public void Add_UniversalResourceElementWithMultipleStrings_OnlyFirstValueIsUsed()
{
var dataset = new DicomDataset();
dataset.Add(DicomTag.URNCodeValue, "a", "b", "c");
Assert.IsType(typeof(DicomUniversalResource), dataset.First());
var data = dataset.Get<string[]>(DicomTag.URNCodeValue);
Assert.Equal(1, data.Length);
Assert.Equal("a", data.First());
}
public void Add_MultiVMStringTags_YieldsMultipleValues(DicomTag tag, string[] values, Type expectedType)
{
var dataset = new DicomDataset();
dataset.Add(tag, values);
Assert.IsType(expectedType, dataset.First(item => item.Tag.Equals(tag)));
var data = dataset.Get<string[]>(tag);
Assert.Equal(values.Length, data.Length);
Assert.Equal(values.Last(), data.Last());
}
public void RegenerateAll(DicomDataset dataset) {
foreach (var ui in dataset.Where(x => x.ValueRepresentation == DicomVR.UI).ToArray()) {
dataset.Add(ui.Tag, Generate(dataset.Get<DicomUID>(ui.Tag)));
}
foreach (var sq in dataset.Where(x => x.ValueRepresentation == DicomVR.SQ).Cast<DicomSequence>().ToArray()) {
foreach (var item in sq) {
RegenerateAll(item);
}
}
}
public void Add_UniversalResourceElementWithMultipleStrings_OnlyFirstValueIsUsed()
{
var tag = DicomTag.URNCodeValue;
var dataset = new DicomDataset();
dataset.Add(tag, "a", "b", "c");
Assert.IsType<DicomUniversalResource>(dataset.First(item => item.Tag.Equals(tag)));
var data = dataset.Get<string[]>(tag);
Assert.Equal(1, data.Length);
Assert.Equal("a", data.First());
}
public void RegenerateAll(DicomDataset dataset) {
foreach (var ui in dataset.Where(x => x.ValueRepresentation == DicomVR.UI).ToArray()) {
var uid = dataset.Get<DicomUID>(ui.Tag);
if (uid.Type == DicomUidType.SOPInstance || uid.Type == DicomUidType.Unknown)
dataset.Add(ui.Tag, Generate(uid));
}
foreach (var sq in dataset.Where(x => x.ValueRepresentation == DicomVR.SQ).Cast<DicomSequence>().ToArray()) {
foreach (var item in sq) {
RegenerateAll(item);
}
}
}
public void Add_PersonName_MultipleNames_YieldsMultipleValues()
{
var dataset = new DicomDataset();
dataset.Add(
DicomTag.PerformingPhysicianName,
"Gustafsson^Anders^L",
"Yates^Ian",
"Desouky^Hesham",
"Horn^Chris");
var data = dataset.Get<string[]>(DicomTag.PerformingPhysicianName);
Assert.Equal(4, data.Length);
Assert.Equal("Desouky^Hesham", data[2]);
}
public void Add_TimeRange_GetDateRangeReturnsValidRange()
{
var dataset =
new DicomDataset(
new DicomUniqueIdentifier(DicomTag.SOPClassUID, DicomUID.SecondaryCaptureImageStorage),
new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"));
var expected = new DicomDateRange(new DateTime(1, 1, 1, 5, 10, 5), new DateTime(1, 1, 1, 19, 0, 20));
dataset.Add(DicomTag.AcquisitionTime, expected);
var actual = dataset.Get<DicomDateRange>(DicomTag.AcquisitionTime);
Assert.Equal(expected.Minimum, actual.Minimum);
Assert.Equal(expected.Maximum, actual.Maximum);
}
public void Get_String_ReturnStringOnDicomValidFormat()
{
var dataset =
new DicomDataset(
new DicomUniqueIdentifier(DicomTag.SOPClassUID, DicomUID.SecondaryCaptureImageStorage),
new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"),
new DicomDateTime(DicomTag.AcquisitionDateTime, new DateTime(2016, 4, 20, 10, 20, 30)));
var zone = DateTime.Now.ToString("yyyyMMddHHmmsszzz").Substring(14).Replace(":", string.Empty);
var expected = $"20160420102030{zone}";
var actual = dataset.Get<string>(DicomTag.AcquisitionDateTime);
Assert.Equal(expected, actual);
}
public void Add_DateRange_GetStringReturnsRangeString()
{
var dataset =
new DicomDataset(
new DicomUniqueIdentifier(DicomTag.SOPClassUID, DicomUID.SecondaryCaptureImageStorage),
new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"));
dataset.Add(
DicomTag.AcquisitionDate,
new DicomDateRange(new DateTime(2016, 4, 20), new DateTime(2016, 4, 21)));
const string expected = "20160420-20160421";
var actual = dataset.Get<string>(DicomTag.AcquisitionDate);
Assert.Equal(expected, actual);
}
public void Add_TimeRange_GetStringReturnsRangeString()
{
var dataset =
new DicomDataset(
new DicomUniqueIdentifier(DicomTag.SOPClassUID, DicomUID.SecondaryCaptureImageStorage),
new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"));
dataset.Add(
DicomTag.AcquisitionTime,
new DicomDateRange(new DateTime(1, 1, 1, 5, 10, 5), new DateTime(1, 1, 1, 19, 0, 20)));
const string expected = "051005-190020";
var actual = dataset.Get<string>(DicomTag.AcquisitionTime);
Assert.Equal(expected, actual);
}
public void CheckAddedPrivateTagValueRepresentation()
{
var privCreatorDictEntry = new DicomDictionaryEntry(new DicomTag(0x0011, 0x0010), "Private Creator", "PrivateCreator", DicomVM.VM_1, false, DicomVR.LO);
DicomDictionary.Default.Add(privCreatorDictEntry);
DicomPrivateCreator privateCreator1 = DicomDictionary.Default.GetPrivateCreator("TESTCREATOR1");
DicomDictionary privDict1 = DicomDictionary.Default[privateCreator1];
var dictEntry = new DicomDictionaryEntry(DicomMaskedTag.Parse("0011", "xx10"), "TestPrivTagName", "TestPrivTagKeyword", DicomVM.VM_1, false, DicomVR.CS);
privDict1.Add(dictEntry);
var ds = new DicomDataset();
ds.Add(dictEntry.Tag, "VAL1");
Assert.Equal(DicomVR.CS, ds.Get<DicomVR>(dictEntry.Tag));
}
public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null) {
IDbConnection connection = null;
try {
if (_dbType == DatabaseType.Odbc)
connection = new OdbcConnection(_connectionString);
else if (_dbType == DatabaseType.MsSql)
connection = new SqlConnection(_connectionString);
using (IDbCommand command = connection.CreateCommand()) {
command.Connection = connection;
command.CommandText = _query;
for (int i = 0; i < _params.Count; i++) {
var str = dataset.Get<string>(_params[i], -1, String.Empty);
SqlParameter prm = new SqlParameter(String.Format("@{0}", i), str);
command.Parameters.Add(prm);
}
connection.Open();
if (_output.Count == 0) {
command.ExecuteNonQuery();
} else {
using (IDataReader reader = command.ExecuteReader()) {
if (reader.Read()) {
for (int i = 0; i < _output.Count; i++) {
dataset.CopyTo(modifiedAttributesSequenceItem, _output[i]);
string str = reader.GetString(i);
dataset.Add(_output[i], str);
}
}
}
}
connection.Close();
connection = null;
}
} finally {
if (connection != null) {
if (connection.State == ConnectionState.Closed || connection.State == ConnectionState.Broken)
connection.Close();
connection.Dispose();
}
}
}
public void Add_StringWithDicomValidTimeZone_ShouldNotThrow()
{
var dataset =
new DicomDataset(
new DicomUniqueIdentifier(DicomTag.SOPClassUID, DicomUID.SecondaryCaptureImageStorage),
new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"));
var zone = DateTime.Now.ToString("yyyyMMddHHmmsszzz").Substring(14).Replace(":", string.Empty);
var exception = Record.Exception(() => dataset.Add(DicomTag.AcquisitionDateTime, $"20160420102030{zone}"));
Assert.Null(exception);
var expected = new DateTime(2016, 4, 20, 10, 20, 30);
var actual = dataset.Get<DateTime>(DicomTag.AcquisitionDateTime);
Assert.Equal(expected, actual);
}
public void Read_ValidSource_ReturnsSuccess()
{
using (var stream = File.OpenRead(@".\Test Data\CT1_J2KI"))
{
var source = new StreamByteSource(stream);
var reader = new DicomFileReader();
var fileMetaInfo = new DicomFileMetaInformation();
var dataset = new DicomDataset();
const DicomReaderResult expected = DicomReaderResult.Success;
var actual = reader.Read(
source,
new DicomDatasetReaderObserver(fileMetaInfo),
new DicomDatasetReaderObserver(dataset));
Assert.Equal(expected, actual);
var modality = dataset.Get<string>(DicomTag.Modality);
Assert.Equal("CT", modality);
}
}
public void Test_RegenerateAll()
{
var uidGenerator = new DicomUIDGenerator();
var dataset = new DicomDataset
{
new DicomPersonName(
DicomTag.PatientName,
new[] { "Anna^Pelle", null, "Olle^Jöns^Pyjamas" }),
{ DicomTag.SOPClassUID, DicomUID.RTPlanStorage },
{ DicomTag.SOPInstanceUID, uidGenerator.Generate() },
{ DicomTag.SeriesInstanceUID,
new[] { uidGenerator.Generate(), uidGenerator.Generate() } },
{ DicomTag.FrameOfReferenceUID, uidGenerator.Generate() }
};
dataset.Add(
DicomTag.ReferencedFrameOfReferenceSequence,
new[]
{
new DicomDataset { { DicomTag.ReferencedFrameOfReferenceUID, uidGenerator.Generate() } },
new DicomDataset { { DicomTag.ReferencedFrameOfReferenceUID, uidGenerator.Generate() } }
});
var clone = this.DeepClone_(dataset);
uidGenerator.RegenerateAll(clone);
Assert.Equal(dataset.Get<string>(DicomTag.PatientName), clone.Get<string>(DicomTag.PatientName));
Assert.Equal(dataset.Get<string>(DicomTag.SOPClassUID), clone.Get<string>(DicomTag.SOPClassUID));
Assert.NotEqual(dataset.Get<string>(DicomTag.SOPInstanceUID), clone.Get<string>(DicomTag.SOPInstanceUID));
Assert.NotEqual(dataset.Get<string>(DicomTag.SeriesInstanceUID), clone.Get<string>(DicomTag.SeriesInstanceUID));
Assert.NotEqual(dataset.Get<string>(DicomTag.FrameOfReferenceUID), clone.Get<string>(DicomTag.FrameOfReferenceUID));
Assert.NotEqual(
dataset.Get<DicomSequence>(DicomTag.ReferencedFrameOfReferenceSequence).Items[0].Get<string>(DicomTag.ReferencedFrameOfReferenceUID),
clone.Get<DicomSequence>(DicomTag.ReferencedFrameOfReferenceSequence).Items[0].Get<string>(DicomTag.ReferencedFrameOfReferenceUID));
Assert.NotEqual(
dataset.Get<DicomSequence>(DicomTag.ReferencedFrameOfReferenceSequence).Items[1].Get<string>(DicomTag.ReferencedFrameOfReferenceUID),
clone.Get<DicomSequence>(DicomTag.ReferencedFrameOfReferenceSequence).Items[1].Get<string>(DicomTag.ReferencedFrameOfReferenceUID));
}
public static GrayscaleRenderOptions FromWindowLevel(DicomDataset dataset)
{
var bits = BitDepth.FromDataset(dataset);
var options = new GrayscaleRenderOptions(bits);
options.RescaleSlope = dataset.Get<double>(DicomTag.RescaleSlope, 1.0);
options.RescaleIntercept = dataset.Get<double>(DicomTag.RescaleIntercept, 0.0);
options.WindowWidth = dataset.Get<double>(DicomTag.WindowWidth);
options.WindowCenter = dataset.Get<double>(DicomTag.WindowCenter);
options.VOILUTFunction = dataset.Get<string>(DicomTag.VOILUTFunction, "LINEAR");
options.Monochrome1 = dataset.Get<PhotometricInterpretation>(DicomTag.PhotometricInterpretation) == PhotometricInterpretation.Monochrome1;
return options;
}
