public override void Apply(IPresentationImage presentationImage) { if (!AppliesTo(presentationImage)) { throw new InvalidOperationException("The input presentation image is not supported."); } IVoiLutManager manager = ((IVoiLutProvider)presentationImage).VoiLutManager; IVoiLut currentLut = manager.VoiLut; if (currentLut is MinMaxPixelCalculatedLinearLut) { return; } GrayscalePixelData pixelData = (GrayscalePixelData)((IImageGraphicProvider)presentationImage).ImageGraphic.PixelData; IModalityLutProvider modalityLutProvider = presentationImage as IModalityLutProvider; if (modalityLutProvider != null) { manager.InstallVoiLut(new MinMaxPixelCalculatedLinearLut(pixelData, modalityLutProvider.ModalityLut)); } else { manager.InstallVoiLut(new MinMaxPixelCalculatedLinearLut(pixelData)); } }
public void ApplyProbabilityThreshold(int threshold, int opacity) { if (!this.ProbabilityMapVisible) { return; } _threshold = threshold; _opacity = opacity; GrayscalePixelData probabilityPixelData = new GrayscalePixelData( _imageGraphic.Rows, _imageGraphic.Columns, _imageGraphic.BitsPerPixel, _imageGraphic.BitsStored, _imageGraphic.HighBit, _imageGraphic.IsSigned, _probabilityMap); probabilityPixelData.ForEachPixel( delegate(int i, int x, int y, int pixelIndex) { if (probabilityPixelData.GetPixel(pixelIndex) < threshold) { _probabilityOverlay.PixelData.SetPixel(pixelIndex, Color.FromArgb(opacity, Color.Red)); } else { _probabilityOverlay.PixelData.SetPixel(pixelIndex, Color.Empty); } }); }
public void ForEachPixel() { int columns = 5; int rows = 4; int bitsAllocated = 16; int bitsStored = 16; int highBit = 15; bool isSigned = true; int samplesPerPixel = 1; int imageSize = columns * rows * bitsAllocated / 8 * samplesPerPixel; byte[] pixelData = new byte[imageSize]; PixelData pixelDataWrapper = new GrayscalePixelData( rows, columns, bitsAllocated, bitsStored, highBit, isSigned, pixelData); int i = 0; for (int y = 0; y < rows; y++) { for (int x = 0; x < columns; x++) { pixelDataWrapper.SetPixel(x, y, i); i++; } } int left = 1, top = 1, right = 3, bottom = 3; int pixelCount = 0; pixelDataWrapper.ForEachPixel(left, top, right, bottom, delegate(int j, int x, int y, int pixelIndex) { if (j == 0) { Assert.AreEqual(6, pixelDataWrapper.GetPixel(pixelIndex)); } else if (j == 1) { Assert.AreEqual(7, pixelDataWrapper.GetPixel(pixelIndex)); } else if (j == 3) { Assert.AreEqual(11, pixelDataWrapper.GetPixel(pixelIndex)); } pixelCount++; }); Assert.AreEqual(9, pixelCount); }
public void Signed9Bit() { int columns = 7; int rows = 19; int bitsAllocated = 16; int bitsStored = 9; int highBit = 8; bool isSigned = true; int samplesPerPixel = 1; int imageSize = columns * rows * bitsAllocated / 8 * samplesPerPixel; byte[] pixelData = new byte[imageSize]; PixelData pixelDataWrapper = new GrayscalePixelData( rows, columns, bitsAllocated, bitsStored, highBit, isSigned, pixelData); pixelData[0] = 255; pixelData[1] = 1; int actualValue = pixelDataWrapper.GetPixel(0, 0); Assert.AreEqual(-1, actualValue); int expectedValue = -1; pixelDataWrapper.SetPixel(0, 0, expectedValue); actualValue = pixelDataWrapper.GetPixel(0, 0); Assert.AreEqual(expectedValue, actualValue); expectedValue = -256; pixelDataWrapper.SetPixel(0, 0, expectedValue); actualValue = pixelDataWrapper.GetPixel(0, 0); Assert.AreEqual(expectedValue, actualValue); expectedValue = 255; pixelDataWrapper.SetPixel(0, 0, expectedValue); actualValue = pixelDataWrapper.GetPixel(0, 0); Assert.AreEqual(expectedValue, actualValue); expectedValue = 0; pixelDataWrapper.SetPixel(0, 0, expectedValue); actualValue = pixelDataWrapper.GetPixel(0, 0); Assert.AreEqual(expectedValue, actualValue); }
public void TestSimple() { byte[] data = new byte[25]; for (byte x = 0; x < 25; ++x) { data[x] = x; } GrayscalePixelData pixelData = new GrayscalePixelData(5, 5, 8, 8, 7, false, data); MinMaxPixelCalculatedLinearLut lut = new MinMaxPixelCalculatedLinearLut(pixelData); lut.MinInputValue = 0; lut.MaxInputValue = 255; Assert.AreEqual(lut.WindowWidth, 24); Assert.AreEqual(lut.WindowCenter, 12); }
/// <summary> /// Creates a packed overlay data object from the contents of this overlay plane. /// </summary> /// <param name="bigEndianWords">A value indciating if the packed overlay data should be encoded as 16-bit words with big endian byte ordering.</param> /// <returns>A packed overlay data object.</returns> public OverlayData CreateOverlayData(bool bigEndianWords) { if (_overlayGraphic == null) { return(null); } GrayscalePixelData pixelData = _overlayGraphic.PixelData; return(OverlayData.CreateOverlayData( pixelData.Rows, pixelData.Columns, pixelData.BitsStored, pixelData.BitsAllocated, pixelData.HighBit, bigEndianWords, pixelData.Raw)); }
public void TestWithModalityLut() { byte[] data = new byte[25]; for (byte x = 0; x < 25; ++x) { data[x] = x; } ModalityLutLinear modalityLut = new ModalityLutLinear(8, true, 1.0, -10); GrayscalePixelData pixelData = new GrayscalePixelData(5, 5, 8, 8, 7, false, data); MinMaxPixelCalculatedLinearLut lut = new MinMaxPixelCalculatedLinearLut(pixelData, modalityLut); lut.MinInputValue = 0; lut.MaxInputValue = 255; Assert.AreEqual(lut.WindowWidth, 24); Assert.AreEqual(lut.WindowCenter, 2); }
public void SetPixelSigned16() { int columns = 7; int rows = 19; int bitsAllocated = 16; int bitsStored = 16; int highBit = 15; bool isSigned = true; int samplesPerPixel = 1; int imageSize = columns * rows * bitsAllocated / 8 * samplesPerPixel; byte[] pixelData = new byte[imageSize]; PixelData pixelDataWrapper = new GrayscalePixelData( rows, columns, bitsAllocated, bitsStored, highBit, isSigned, pixelData); int x = 3; int y = 4; // Test the API int testValue = -1234; pixelDataWrapper.SetPixel(x, y, testValue); int actualValue = pixelDataWrapper.GetPixel(x, y); Assert.AreEqual(testValue, actualValue); // Make sure it works with unsafe code too fixed(byte *pPixelData = pixelDataWrapper.Raw) { short *pShortPixelData = (short *)pPixelData; int i = y * columns + x; actualValue = pShortPixelData[i]; } Assert.AreEqual(testValue, actualValue); }
private bool ComputeHistogram(Roi roi) { // For now, only allow ROIs of grayscale images GrayscalePixelData pixelData = roi.PixelData as GrayscalePixelData; if (pixelData == null) { this.Enabled = false; return(false); } int left = (int)Math.Round(roi.BoundingBox.Left); int right = (int)Math.Round(roi.BoundingBox.Right); int top = (int)Math.Round(roi.BoundingBox.Top); int bottom = (int)Math.Round(roi.BoundingBox.Bottom); // If any part of the ROI is outside the bounds of the image, // don't allow a histogram to be displayed since it's invalid. if (left < 0 || left > pixelData.Columns - 1 || right < 0 || right > pixelData.Columns - 1 || top < 0 || top > pixelData.Rows - 1 || bottom < 0 || bottom > pixelData.Rows - 1) { this.Enabled = false; return(false); } var roiPixelData = new List <double>(roi.GetPixelValues()).ToArray(); Histogram histogram = new Histogram( _minBin, _maxBin, _numBins, roiPixelData); _bins = histogram.Bins; _binLabels = histogram.BinLabels; NotifyPropertyChanged("MinBin"); NotifyPropertyChanged("MaxBin"); NotifyPropertyChanged("NumBins"); this.Enabled = true; return(true); }
public void SetPixelUnsigned8() { int columns = 7; int rows = 19; int bitsAllocated = 8; int bitsStored = 8; int highBit = 7; bool isSigned = false; int samplesPerPixel = 1; int imageSize = columns * rows * bitsAllocated / 8 * samplesPerPixel; byte[] pixelData = new byte[imageSize]; PixelData pixelDataWrapper = new GrayscalePixelData( rows, columns, bitsAllocated, bitsStored, highBit, isSigned, pixelData); int x = 3; int y = 4; int testValue = 0xab; pixelDataWrapper.SetPixel(x, y, testValue); int actualValue = pixelDataWrapper.GetPixel(x, y); Assert.AreEqual(testValue, actualValue); // Make sure it works with unsafe code too fixed(byte *pPixelData = pixelDataWrapper.Raw) { int i = y * columns + x; actualValue = pPixelData[i]; } Assert.AreEqual(testValue, actualValue); }
private static double CalculateMean ( RectangleF roiBoundingBox, GrayscalePixelData pixelData, IModalityLut modalityLut, IsPointInRoiDelegate isPointInRoi ) { double sum = 0; int pixelCount = 0; var boundingBox = RectangleUtilities.RoundInflate(RectangleUtilities.ConvertToPositiveRectangle(roiBoundingBox)); pixelData.ForEachPixel( boundingBox.Left, boundingBox.Top, boundingBox.Right, boundingBox.Bottom, delegate(int i, int x, int y, int pixelIndex) { if (isPointInRoi(x, y)) { ++pixelCount; // Make sure we run the raw pixel through the modality LUT // when doing the calculation. Note that the modality LUT // can be something other than a rescale intercept, so we can't // just run the mean through the LUT. int storedValue = pixelData.GetPixel(pixelIndex); double realValue = modalityLut != null ? modalityLut[storedValue] : storedValue; sum += realValue; } }); if (pixelCount == 0) { return(0); } return(sum / pixelCount); }
private static double CalculateStandardDeviation ( double mean, RectangleF roiBoundingBox, GrayscalePixelData pixelData, IModalityLut modalityLut, IsPointInRoiDelegate isPointInRoi ) { double sum = 0; int pixelCount = 0; var boundingBox = RectangleUtilities.RoundInflate(RectangleUtilities.ConvertToPositiveRectangle(roiBoundingBox)); pixelData.ForEachPixel( boundingBox.Left, boundingBox.Top, boundingBox.Right, boundingBox.Bottom, delegate(int i, int x, int y, int pixelIndex) { if (isPointInRoi(x, y)) { ++pixelCount; int storedValue = pixelData.GetPixel(pixelIndex); double realValue = modalityLut != null ? modalityLut[storedValue] : storedValue; double deviation = realValue - mean; sum += deviation * deviation; } }); if (pixelCount == 0) { return(0); } return(Math.Sqrt(sum / pixelCount)); }
public void SetPixelSigned16Grayscale() { int columns = 7; int rows = 19; int bitsAllocated = 16; int bitsStored = 16; int highBit = 15; bool isSigned = true; int samplesPerPixel = 1; int imageSize = columns * rows * bitsAllocated / 8 * samplesPerPixel; byte[] pixelData = new byte[imageSize]; PixelData pixelDataWrapper = new GrayscalePixelData( rows, columns, bitsAllocated, bitsStored, highBit, isSigned, pixelData); int x = 3; int y = 4; // Test the API int testValue = -1234; pixelDataWrapper.SetPixel(x, y, testValue); int actualValue = pixelDataWrapper.GetPixel(x, y); Assert.AreEqual(testValue, actualValue); int index = y * columns + x; actualValue = pixelDataWrapper.GetPixel(index); Assert.AreEqual(testValue, actualValue); }
public void Signed5Bit16BitsAllocated() { int columns = 7; int rows = 19; int bitsAllocated = 16; int bitsStored = 5; int highBit = 4; bool isSigned = true; int samplesPerPixel = 1; int imageSize = columns * rows * bitsAllocated / 8 * samplesPerPixel; byte[] pixelData = new byte[imageSize]; PixelData pixelDataWrapper = new GrayscalePixelData( rows, columns, bitsAllocated, bitsStored, highBit, isSigned, pixelData); Signed5Bit(pixelData, pixelDataWrapper); }