private static void ProcessOverlays(DicomDataset input, DicomDataset output)
        {
            var overlays = DicomOverlayData.FromDataset(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;
                }

                output.Add(new DicomTag(overlay.Group, DicomTag.OverlayBitsAllocated.Element), (ushort)1);
                output.Add(new DicomTag(overlay.Group, DicomTag.OverlayBitPosition.Element), (ushort)0);

                var data = overlay.Data;
                if (output.InternalTransferSyntax.IsExplicitVR)
                {
                    output.Add(new DicomOtherByte(dataTag, data));
                }
                else
                {
                    output.Add(new DicomOtherWord(dataTag, data));
                }
            }
        }
Exemple #2
0
        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));
                }
            }
        }
        public void OverlayTypeGetter_TypeNotSet_ShouldThrow()
        {
            const ushort group = 0x6008;

            var dataset = new DicomDataset();
            var od      = new DicomOverlayData(dataset, group);

            var exception = Record.Exception(() => od.Type);

            Assert.NotNull(exception);
        }
        public void OverlayTypeGetter_TypeSetToOtherThanRAndG_ShouldThrow()
        {
            const ushort group = 0x6001;

            var dataset = new DicomDataset();
            var od      = new DicomOverlayData(dataset, group);

            dataset.AddOrUpdate(new DicomTag(group, 0x0040), "O");

            var exception = Record.Exception(() => od.Type);

            Assert.NotNull(exception);
        }
        public void OriginYGetter_ReturnsValueAtIndex0()
        {
            const int    expected = 42;
            const ushort group    = 0x6012;

            var dataset = new DicomDataset();
            var od      = new DicomOverlayData(dataset, group);

            dataset.AddOrUpdate(new DicomTag(group, 0x0050), "42", "0");

            var actual = od.OriginY;

            Assert.Equal(expected, actual);
        }
        public void OverlayTypeGetter_TypeSetToR_ReturnsROI()
        {
            const DicomOverlayType expected = DicomOverlayType.ROI;
            const ushort           group    = 0x6012;

            var dataset = new DicomDataset();
            var od      = new DicomOverlayData(dataset, group);

            dataset.AddOrUpdate(new DicomTag(group, 0x0040), "R");

            var actual = od.Type;

            Assert.Equal(expected, actual);
        }
        public void OverlayTypeSetter_SetToROI_ReturnsR()
        {
            const string expected = "R";
            const ushort group    = 0x6011;

            var dataset = new DicomDataset();

            _ = new DicomOverlayData(dataset, group)
            {
                Type = DicomOverlayType.ROI
            };

            var actual = dataset.GetString(new DicomTag(group, 0x0040));

            Assert.Equal(expected, actual);
        }
        public void Constructor_GroupSpecified_GroupTransferredToLabel()
        {
            const string expected = "Label 6003";
            const ushort group    = 0x6003;

            var dataset = new DicomDataset();

            _ = new DicomOverlayData(dataset, group)
            {
                Label = expected
            };

            var actual = dataset.GetString(new DicomTag(group, 0x1500));

            Assert.Equal(expected, actual);
        }
        public void Constructor_GroupSpecified_GroupTransferredToSubtype()
        {
            const string expected = "Subtype 6005";
            const ushort group    = 0x6005;

            var dataset = new DicomDataset();

            _ = new DicomOverlayData(dataset, group)
            {
                Subtype = expected
            };

            var actual = dataset.GetString(new DicomTag(group, 0x0045));

            Assert.Equal(expected, actual);
        }
        public void OriginYSetter_ReturnsValueAtIndex0()
        {
            const int    expected = 96;
            const ushort group    = 0x6012;

            var dataset = new DicomDataset();

            _ = new DicomOverlayData(dataset, group)
            {
                OriginY = expected
            };

            int originY = dataset.GetValueOrDefault <short>(new DicomTag(group, 0x0050), 0, 1);

            Assert.Equal(expected, originY);
        }
        public void Constructor_GroupSpecified_GroupTransferredToDescription()
        {
            const string expected = "Description 6002";
            const ushort group    = 0x6002;

            var dataset = new DicomDataset();

            _ = new DicomOverlayData(dataset, group)
            {
                Description = expected
            };

            var actual = dataset.GetString(new DicomTag(group, 0x0022));

            Assert.Equal(expected, actual);
        }
Exemple #12
0
        public static DicomDataset ExtractOverlays(DicomDataset dataset)
        {
            if (!DicomOverlayData.HasEmbeddedOverlays(dataset))
            {
                return(dataset);
            }

            dataset = dataset.Clone();

            var input = dataset;

            if (input.InternalTransferSyntax.IsEncapsulated)
            {
                input = input.ChangeTransferSyntax(DicomTransferSyntax.ExplicitVRLittleEndian);
            }

            ProcessOverlays(input, dataset);

            return(dataset);
        }
Exemple #13
0
 /// <summary>
 /// Create <see cref="SingleBitPixelData"/> form <see cref="DicomOverlayData"/> 
 /// according to the input <paramref name="overlayData"/>
 /// </summary>
 /// <param name="overlayData">The input overlay data</param>
 /// <returns>The result overlay stored in <seealso cref="SingleBitPixelData"/></returns>
 public static SingleBitPixelData Create(DicomOverlayData overlayData)
 {
     return new SingleBitPixelData(overlayData.Columns, overlayData.Rows, overlayData.Data);
 }
Exemple #14
0
 /// <summary>
 /// Create <see cref="SingleBitPixelData"/> form <see cref="DicomOverlayData"/> 
 /// according to the input <paramref name="overlayData"/>
 /// </summary>
 /// <param name="overlayData">The input overlay data</param>
 /// <returns>The result overlay stored in <seealso cref="SingleBitPixelData"/></returns>
 public static SingleBitPixelData Create(DicomOverlayData overlayData)
 {
     return new SingleBitPixelData(overlayData.Columns, overlayData.Rows, overlayData.Data);
 }