/// <summary>
        /// Creates a DICOM overlay from a GDI+ Bitmap.
        /// </summary>
        /// <param name="ds">Dataset</param>
        /// <param name="bitmap">Bitmap</param>
        /// <param name="mask">Color mask for overlay</param>
        /// <returns>DICOM overlay</returns>
        public static DicomOverlayData FromBitmap(DicomDataset ds, Bitmap bitmap, Color mask)
        {
            ushort group = 0x6000;
            while (ds.Contains(new DicomTag(group, DicomTag.OverlayBitPosition.Element))) group += 2;

            var overlay = new DicomOverlayData(ds, group)
                              {
                                  Type = DicomOverlayType.Graphics,
                                  Rows = bitmap.Height,
                                  Columns = bitmap.Width,
                                  OriginX = 1,
                                  OriginY = 1,
                                  BitsAllocated = 1,
                                  BitPosition = 1
                              };

            var array = new BitList { Capacity = overlay.Rows * overlay.Columns };

            int p = 0;
            for (var y = 0; y < bitmap.Height; y++)
            {
                for (var x = 0; x < bitmap.Width; x++, p++)
                {
                    if (bitmap.GetPixel(x, y).ToArgb() == mask.ToArgb()) array[p] = true;
                }
            }

            overlay.Data = EvenLengthBuffer.Create(new MemoryByteBuffer(array.Array));

            return overlay;
        }
Esempio n. 2
0
        private IByteBuffer Load()
        {
            var tag = OverlayTag(DicomTag.OverlayData);
            if (Dataset.Contains(tag))
            {
                var elem = Dataset.FirstOrDefault(x => x.Tag == tag) as DicomElement;
                return elem.Buffer;
            }
            else
            {
                // overlay embedded in high bits of pixel data
                if (Dataset.InternalTransferSyntax.IsEncapsulated)
                    throw new DicomImagingException(
                        "Attempted to extract embedded overlay from compressed pixel data. Decompress pixel data before attempting this operation.");

                var pixels = DicomPixelData.Create(Dataset);

                // (1,1) indicates top left pixel of image
                int ox = Math.Max(0, OriginX - 1);
                int oy = Math.Max(0, OriginY - 1);
                int ow = Rows - (pixels.Width - Rows - ox);
                int oh = Columns - (pixels.Height - Columns - oy);

                var frame = pixels.GetFrame(0);

                var bits = new BitList();
                bits.Capacity = Rows * Columns;
                int mask = 1 << BitPosition;

                if (pixels.BitsAllocated == 8)
                {
                    var data = IO.ByteConverter.ToArray<byte>(frame);

                    for (int y = oy; y < oh; y++)
                    {
                        int n = (y * pixels.Width) + ox;
                        int i = (y - oy) * Columns;
                        for (int x = ox; x < ow; x++)
                        {
                            if ((data[n] & mask) != 0) bits[i] = true;
                            n++;
                            i++;
                        }
                    }
                }
                else if (pixels.BitsAllocated == 16)
                {
                    // we don't really care if the pixel data is signed or not
                    var data = IO.ByteConverter.ToArray<ushort>(frame);

                    for (int y = oy; y < oh; y++)
                    {
                        int n = (y * pixels.Width) + ox;
                        int i = (y - oy) * Columns;
                        for (int x = ox; x < ow; x++)
                        {
                            if ((data[n] & mask) != 0) bits[i] = true;
                            n++;
                            i++;
                        }
                    }
                }
                else
                {
                    throw new DicomImagingException(
                        "Unable to extract embedded overlay from pixel data with bits stored greater than 16.");
                }

                return new MemoryByteBuffer(bits.Array);
            }
        }
		public static DicomOverlayData FromBitmap(DicomDataset ds, Bitmap bitmap, Color mask) {
#endif
			ushort group = 0x6000;
			while (ds.Contains(new DicomTag(group, DicomTag.OverlayBitPosition.Element)))
				group += 2;

			var overlay = new DicomOverlayData(ds, group);
			overlay.Type = DicomOverlayType.Graphics;
#if NETFX_CORE || SILVERLIGHT
			overlay.Rows = bitmap.PixelHeight;
			overlay.Columns = bitmap.PixelWidth;
#else
			overlay.Rows = bitmap.Height;
			overlay.Columns = bitmap.Width;
#endif
			overlay.OriginX = 1;
			overlay.OriginY = 1;
			overlay.BitsAllocated = 1;
			overlay.BitPosition = 1;

			var count = overlay.Rows * overlay.Columns / 8;
			if ((overlay.Rows * overlay.Columns) % 8 > 0)
				count++;

			var array = new BitList();
			array.Capacity = overlay.Rows * overlay.Columns;

#if NETFX_CORE || SILVERLIGHT
			int p = 0;
			for (int y = 0; y < bitmap.PixelHeight; y++)
			{
				for (int x = 0; x < bitmap.PixelWidth; x++, p++)
				{
					if (bitmap.GetPixel(x, y).ToArgb() == mask.ToArgb())
						array[p] = true;
#else
			int p = 0;
			for (int y = 0; y < bitmap.Height; y++) {
				for (int x = 0; x < bitmap.Width; x++, p++) {
					if (bitmap.GetPixel(x, y).ToArgb() == mask.ToArgb())
						array[p] = true;
#endif
				}
			}

			overlay.Data = EvenLengthBuffer.Create(
									new MemoryByteBuffer(array.Array));

			return overlay;
		}