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 void FromWindowLevel_ValidInput_CorrectOutput(
            ushort bitsAllocated,
            ushort bitsStored,
            ushort pixelRepresentation,
            double rescaleSlope,
            double rescaleIntercept,
            double windowWidth,
            double windowCenter,
            string voiLutFunction)
        {
            var dataset = new DicomDataset(
                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 actual = GrayscaleRenderOptions.FromWindowLevel(dataset);

            Assert.Equal(windowWidth, actual.WindowWidth);
            Assert.Equal(windowCenter, actual.WindowCenter);
        }

 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 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 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 DicomFile()
 {
     FileMetaInfo = new DicomFileMetaInformation();
     Dataset = new DicomDataset();
     Format = DicomFileFormat.DICOM3;
     IsPartial = false;
 }

        /// <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;
        }

 public DicomFileMetaInformation(DicomDataset dataset)
     : this()
 {
     MediaStorageSOPClassUID = dataset.Get<DicomUID>(DicomTag.SOPClassUID);
     MediaStorageSOPInstanceUID = dataset.Get<DicomUID>(DicomTag.SOPInstanceUID);
     TransferSyntax = dataset.InternalTransferSyntax;
 }

 public void Contains_PrivateTag_SufficientlyFound()
 {
     var dataset = new DicomDataset();
     dataset.Add(new DicomTag(0x0021, 0x0010, "TEST"), "TEST");
     var found = dataset.Contains(new DicomTag(0x0021, 0x0010, "TEST"));
     Assert.True(found);
 }

 public void Add_OtherDoubleElement_Succeeds()
 {
     var tag = DicomTag.DoubleFloatPixelData;
     var dataset = new DicomDataset();
     dataset.Add(tag, 3.45);
     Assert.IsType<DicomOtherDouble>(dataset.First(item => item.Tag.Equals(tag)));
 }

		public void Transform(DicomDataset dataset, DicomDataset modifiedAttributesSequenceItem = null) {
			var remove = dataset.EnumerateMasked(_mask).Select(x => x.Tag).ToList();
			foreach (DicomTag tag in remove) {
				dataset.CopyTo(modifiedAttributesSequenceItem, tag);
				dataset.Remove(tag);
			}
		}

 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));
 }

        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 static byte[] SerializeDicom_(DicomDataset dataset)
 {
     var stream = new MemoryStream();
     var file = new DicomFile(dataset);
     file.Save(stream);
     return stream.ToArray();
 }

		public DicomCMoveRequest(string destinationAe, string studyInstanceUid, string seriesInstanceUid, DicomPriority priority = DicomPriority.Medium) : base(DicomCommandField.CMoveRequest, DicomUID.StudyRootQueryRetrieveInformationModelMOVE, priority) {
			DestinationAE = destinationAe;
			Dataset = new DicomDataset();
			Level = DicomQueryRetrieveLevel.Series;
			Dataset.Add(DicomTag.StudyInstanceUID, studyInstanceUid);
			Dataset.Add(DicomTag.SeriesInstanceUID, seriesInstanceUid);
		}

        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 DicomDatasetWalkerTest()
        {
            var dataset = new DicomDataset(
                new DicomUniqueIdentifier(DicomTag.SOPClassUID, DicomUID.RTDoseStorage),
                new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"),
                new DicomDate(DicomTag.AcquisitionDate, DateTime.Today),
                new DicomPersonName(DicomTag.ConsultingPhysicianName, "Doe", "John"),
                new DicomDecimalString(DicomTag.GridFrameOffsetVector, 1.0m, 2.0m, 3.0m, 4.0m, 5.0m, 6.0m),
                new DicomSequence(
                    DicomTag.BeamSequence,
                    new DicomDataset(
                        new DicomIntegerString(DicomTag.BeamNumber, 1),
                        new DicomDecimalString(DicomTag.FinalCumulativeMetersetWeight, 1.0m),
                        new DicomLongString(DicomTag.BeamName, "Ant")),
                    new DicomDataset(
                        new DicomIntegerString(DicomTag.BeamNumber, 2),
                        new DicomDecimalString(DicomTag.FinalCumulativeMetersetWeight, 100.0m),
                        new DicomLongString(DicomTag.BeamName, "Post")),
                    new DicomDataset(
                        new DicomIntegerString(DicomTag.BeamNumber, 3),
                        new DicomDecimalString(DicomTag.FinalCumulativeMetersetWeight, 2.0m),
                        new DicomLongString(DicomTag.BeamName, "Left"))),
                new DicomIntegerString(DicomTag.NumberOfContourPoints, 120));

            this.walker = new DicomDatasetWalker(dataset);
            this.walkerImpl = new DatasetWalkerImpl();
        }

 public PresentationLut(DicomUID sopInstance, DicomDataset dataset)
 {
     if (dataset == null)
     {
         throw new ArgumentNullException("dataset");
     }
     dataset.CopyTo(this);
 }

		public void OnBeginSequenceItem(IByteSource source, uint length) {
			DicomSequence sq = _sequences.Peek();

			DicomDataset item = new DicomDataset();
			sq.Items.Add(item);

			_datasets.Push(item);
		}

 private static DicomDataset ReadFragment(byte[] bytes, Endian endian, bool explicitVr)
 {
   var dataset = new DicomDataset();
   var reader = new DicomReader { IsExplicitVR = explicitVr };
   var byteSource = new ByteBufferByteSource(new MemoryByteBuffer(bytes)) { Endian = endian };
   reader.Read(byteSource, new DicomDatasetReaderObserver(dataset));
   return dataset;
 }