public void FromDataset_WindowCenterWidth_ReturnsSameAsFromWindowLevel(
ushort bitsAllocated,
ushort bitsStored,
ushort pixelRepresentation,
double rescaleSlope,
double rescaleIntercept,
double windowWidth,
double windowCenter,
string voiLutFunction)
{
var dataset = new DicomDataset(
new DicomCodeString(DicomTag.PhotometricInterpretation, "MONOCHROME1"),
new DicomUnsignedShort(DicomTag.BitsAllocated, bitsAllocated),
new DicomUnsignedShort(DicomTag.BitsStored, bitsStored),
new DicomUnsignedShort(DicomTag.PixelRepresentation, pixelRepresentation),
new DicomDecimalString(DicomTag.RescaleSlope, (decimal)rescaleSlope),
new DicomDecimalString(DicomTag.RescaleIntercept, (decimal)rescaleIntercept),
new DicomDecimalString(DicomTag.WindowWidth, (decimal)windowWidth),
new DicomDecimalString(DicomTag.WindowCenter, (decimal)windowCenter),
new DicomCodeString(DicomTag.VOILUTFunction, voiLutFunction));
var expected = GrayscaleRenderOptions.FromWindowLevel(dataset);
var actual = GrayscaleRenderOptions.FromDataset(dataset);
Assert.Equal(expected.WindowWidth, actual.WindowWidth);
Assert.Equal(expected.WindowCenter, actual.WindowCenter);
}
public void ColorMap_Monochrome2ImageOptions_ReturnsMonochrome2ColorMap()
{
var file = DicomFile.Open(TestData.Resolve("CT1_J2KI"));
var options = GrayscaleRenderOptions.FromDataset(file.Dataset);
Assert.Same(ColorTable.Monochrome2, options.ColorMap);
}
public void FromDataset_PixelLimits_ReturnsSameAsFromImagePixelValueTags(
ushort bitsAllocated,
ushort bitsStored,
double rescaleSlope,
double rescaleIntercept,
short smallestImagePixelValue,
short largestImagePixelValue,
string voiLutFunction,
double expectedWindowWidth,
double expectedWindowCenter)
{
var dataset = new DicomDataset(
new DicomCodeString(DicomTag.PhotometricInterpretation, "MONOCHROME1"),
new DicomUnsignedShort(DicomTag.BitsAllocated, bitsAllocated),
new DicomUnsignedShort(DicomTag.BitsStored, bitsStored),
new DicomUnsignedShort(DicomTag.PixelRepresentation, 1),
new DicomDecimalString(DicomTag.RescaleSlope, (decimal)rescaleSlope),
new DicomDecimalString(DicomTag.RescaleIntercept, (decimal)rescaleIntercept),
new DicomSignedShort(DicomTag.SmallestImagePixelValue, smallestImagePixelValue),
new DicomSignedShort(DicomTag.LargestImagePixelValue, largestImagePixelValue),
new DicomCodeString(DicomTag.VOILUTFunction, voiLutFunction));
var expected = GrayscaleRenderOptions.FromImagePixelValueTags(dataset);
var actual = GrayscaleRenderOptions.FromDataset(dataset);
Assert.Equal(expected.WindowWidth, actual.WindowWidth);
Assert.Equal(expected.WindowCenter, actual.WindowCenter);
}
public void ColorMap_Setter_ReturnsSetColorMap()
{
var file = DicomFile.Open(TestData.Resolve("CT1_J2KI"));
var options = GrayscaleRenderOptions.FromDataset(file.Dataset);
options.ColorMap = ColorTable.Monochrome1;
Assert.Same(ColorTable.Monochrome1, options.ColorMap);
}
public void ModalityRescaleLutReturnsCorrectRescaleSlope()
{
var file = DicomFile.Open(@".\Test Data\CR-ModalitySequenceLUT.dcm");
var options = GrayscaleRenderOptions.FromDataset(file.Dataset);
var lut = new ModalityRescaleLUT(options);
Assert.Equal(1.0, lut.RescaleSlope);
}
public void ModalitySequenceLutReturnsCorrectMaximumValue()
{
var file = DicomFile.Open(@".\Test Data\CR-ModalitySequenceLUT.dcm");
var options = GrayscaleRenderOptions.FromDataset(file.Dataset);
var lut = new ModalitySequenceLUT(options);
Assert.Equal(1023, lut.MaximumOutputValue);
}
public void ColorMap_Monochrome2ImageOptions_ReturnsMonochrome2ColorMap()
{
var file = DicomFile.Open(@".\Test Data\CT1_J2KI");
var options = GrayscaleRenderOptions.FromDataset(file.Dataset);
var lut = new OutputLUT(options);
Assert.Same(ColorTable.Monochrome2, lut.ColorMap);
}
public void ModalitySequenceLutReturnsCorrectMinimumValue()
{
var file = DicomFile.Open(TestData.Resolve("CR-ModalitySequenceLUT.dcm"));
var options = GrayscaleRenderOptions.FromDataset(file.Dataset);
var lut = new ModalitySequenceLUT(options);
Assert.Equal(0, lut.MinimumOutputValue);
}
public void ModalityRescaleLutReturnsCorrectRescaleIntercept()
{
var file = DicomFile.Open(TestData.Resolve("CR-ModalitySequenceLUT.dcm"));
var options = GrayscaleRenderOptions.FromDataset(file.Dataset);
var lut = new ModalityRescaleLUT(options);
Assert.Equal(0.0, lut.RescaleIntercept);
}
/// <summary>
///
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
private static int[] GetIntPixels(DicomImage image)
{
var gro = GrayscaleRenderOptions.FromDataset(image.Dataset);
var voilut = VOILUT.Create(gro);
var ipd = PixelDataFactory.Create(image.PixelData, 0);
int[] outPixelsInt = new int[image.Width * image.Height];
ipd.Render(voilut, outPixelsInt);
return(outPixelsInt);
}
private static int[] GetGrayPixelData(DicomDataset dataset)
{
DicomPixelData pixelData = DicomPixelData.Create(dataset);
IByteBuffer buffer = pixelData.GetFrame(0);
IPixelData data = PixelDataFactory.Create(pixelData, 0);
var renderOptions = GrayscaleRenderOptions.FromDataset(dataset);
int[] output = new int[pixelData.Width * pixelData.Height];
data.Render(new ModalityLUT(renderOptions), output);
return(output);
}
private void OnKeyUp(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.Right)
{
_frame++;
if (_frame >= _image.NumberOfFrames)
{
_frame--;
}
DisplayImage(_image);
return;
}
if (e.KeyCode == Keys.Left)
{
_frame--;
if (_frame < 0)
{
_frame++;
}
DisplayImage(_image);
return;
}
if (e.KeyCode == Keys.O)
{
_image.ShowOverlays = !_image.ShowOverlays;
DisplayImage(_image);
return;
}
GrayscaleRenderOptions options = null;
if (e.KeyCode == Keys.D0)
{
options = GrayscaleRenderOptions.FromDataset(_image.Dataset);
}
else if (e.KeyCode == Keys.D1)
{
options = GrayscaleRenderOptions.FromWindowLevel(_image.Dataset);
}
else if (e.KeyCode == Keys.D2)
{
options = GrayscaleRenderOptions.FromImagePixelValueTags(_image.Dataset);
}
else if (e.KeyCode == Keys.D3)
{
options = GrayscaleRenderOptions.FromMinMax(_image.Dataset);
}
else if (e.KeyCode == Keys.D4)
{
options = GrayscaleRenderOptions.FromBitRange(_image.Dataset);
}
else if (e.KeyCode == Keys.D5)
{
options = GrayscaleRenderOptions.FromHistogram(_image.Dataset, 90);
}
if (options != null)
{
_image.WindowWidth = options.WindowWidth;
_image.WindowCenter = options.WindowCenter;
DisplayImage(_image);
}
}
void StoreImage(DicomDataset ds, string modality)
{
DicomImage di = new DicomImage(ds);
// store in cached resource
var idc = new ImageDataContract();
idc.PatientId = ds.Get <string>(DicomTag.PatientID);
if (ds.Contains(DicomTag.PixelSpacing))
{
idc.PixelSpacing = new VoxelSize()
{
X = Convert.ToSingle(ds.Get <double>(DicomTag.PixelSpacing, 0)),
Y = Convert.ToSingle(ds.Get <double>(DicomTag.PixelSpacing, 1)),
};
}
else
{
idc.PixelSpacing = new VoxelSize()
{
X = 1.0f,
Y = 1.0f,
};
}
idc.ImagePosition = new ImagePosition()
{
X = Convert.ToSingle(ds.Get <double>(DicomTag.ImagePositionPatient, 0)),
Y = Convert.ToSingle(ds.Get <double>(DicomTag.ImagePositionPatient, 1)),
Z = Convert.ToSingle(ds.Get <double>(DicomTag.ImagePositionPatient, 2)),
};
idc.ImageOrientation = new ImageOrientation();
idc.ImageOrientation.Row = new DirectionCosine()
{
X = Convert.ToSingle(ds.Get <double>(DicomTag.ImageOrientationPatient, 0)),
Y = Convert.ToSingle(ds.Get <double>(DicomTag.ImageOrientationPatient, 1)),
Z = Convert.ToSingle(ds.Get <double>(DicomTag.ImageOrientationPatient, 2)),
};
idc.ImageOrientation.Column = new DirectionCosine()
{
X = Convert.ToSingle(ds.Get <double>(DicomTag.ImageOrientationPatient, 3)),
Y = Convert.ToSingle(ds.Get <double>(DicomTag.ImageOrientationPatient, 4)),
Z = Convert.ToSingle(ds.Get <double>(DicomTag.ImageOrientationPatient, 5)),
};
idc.Width = di.Width;
idc.Height = di.Height;
idc.Label = string.Format("{0} {1}",
modality,
ds.GetDateTime(DicomTag.SeriesDate, DicomTag.SeriesTime).ToString());
idc.SeriesInstanceUID = ds.Get <string>(DicomTag.SeriesInstanceUID);
// store for association closed event
_seriesInstanceUIDs.Add(idc.SeriesInstanceUID);
string for_uid = ds.Get <string>(DicomTag.FrameOfReferenceUID);
idc.FrameOfReferenceUID = for_uid;
LocalImageResourceManagerClient
cache1 = new LocalImageResourceManagerClient();
idc = cache1.AddImage(idc);
double repoGb = cache1.GetRepositorySizeGB();
cache1.Close();
if (di.PhotometricInterpretation == PhotometricInterpretation.Monochrome1 ||
di.PhotometricInterpretation == PhotometricInterpretation.Monochrome2)
{
var dsForWl = di.Dataset;
if (_firstImageIn.ContainsKey(idc.SeriesInstanceUID))
{
dsForWl = _firstImageIn[idc.SeriesInstanceUID].Dataset;
}
else
{
_firstImageIn.TryAdd(idc.SeriesInstanceUID, di);
}
var gro = GrayscaleRenderOptions.FromDataset(dsForWl);
var voilut = VOILUT.Create(gro);
var ipd = PixelDataFactory.Create(di.PixelData, 0);
int[] outPixelsInt = new int[di.Width * di.Height];
ipd.Render(voilut, outPixelsInt);
ushort[] outPixelsUshort = Array.ConvertAll(outPixelsInt,
new Converter <int, ushort>(inInt => (ushort)(inInt)));
var handle = idc.PixelBuffer.GetHandle();
handle.WriteArray <ushort>(0, outPixelsUshort, 0, outPixelsUshort.Length);
idc.PixelBuffer.ReleaseHandle();
idc.PixelBuffer.CloseMapping();
// publish the image stored message
_endpointInstance.Publish(new ImageStored
{
ImageGuid = idc.ImageId,
RepoGb = repoGb,
});
}
}