public static WindowLevel[] FromDataset(DcmDataset dataset)
        {
            List<WindowLevel> settings = new List<WindowLevel>();

            if (dataset.Contains(DicomTags.WindowCenter) && dataset.Contains(DicomTags.WindowWidth)) {
                string[] wc = dataset.GetDS(DicomTags.WindowCenter).GetValues();
                string[] ww = dataset.GetDS(DicomTags.WindowWidth).GetValues();

                if (wc.Length != ww.Length)
                    throw new DicomImagingException("Window Center count does not match Window Width count");

                string[] desc = null;
                if (dataset.Contains(DicomTags.WindowCenterWidthExplanation)) {
                    desc = dataset.GetLO(DicomTags.WindowCenterWidthExplanation).GetValues();
                }

                for (int i = 0; i < wc.Length; i++) {
                    double window;
                    double level;
                    if (!Double.TryParse(ww[i], out window) || !Double.TryParse(wc[i], out level))
                        throw new DicomImagingException("Unable to parse Window/Level [wc: {0}; ww: {1}]", wc[i], ww[i]);

                    string description = String.Empty;
                    if (desc != null && i < desc.Length)
                        description = desc[i];

                    settings.Add(new WindowLevel(description, window, level));
                }
            }

            return settings.ToArray();
        }

 /// <summary>
 /// Initializes new Basic Film Box
 /// </summary>
 /// <param name="session">Basic Film Session</param>
 /// <param name="sopInstance">SOP Instance UID</param>
 /// <param name="dataset">Dataset</param>
 public DcmFilmBox(DcmFilmSession session, DicomUID sopInstance, DcmDataset dataset)
 {
     _session = session;
     _sopInstance = sopInstance;
     _dataset = dataset;
     _boxes = new List<DcmImageBox>();
 }

 /// <summary>
 /// Initializes new Basic Image Box
 /// </summary>
 /// <param name="filmBox">Basic Film Box</param>
 /// <param name="sopClass">SOP Class UID</param>
 /// <param name="sopInstance">SOP Instance UID</param>
 public DcmImageBox(DcmFilmBox filmBox, DicomUID sopClass, DicomUID sopInstance)
 {
     _filmBox = filmBox;
     _sopClass = sopClass;
     _sopInstance = sopInstance;
     _dataset = new DcmDataset(DicomTransferSyntax.ImplicitVRLittleEndian);
 }

        private void LoadDataset(DcmDataset ds, Collection<Node> parent)
        {
            if (ds == null)
                return;

            foreach (DcmItem di in ds.Elements) {
                Image icon = LoadTreeViewAdvResourceImage("Leaf", di.VR.VR, Color.Blue);

                DicomNode dn = new DicomNode(icon, di);
                parent.Add(dn);

                if (di is DcmItemSequence) {
                    dn.Icon = LoadTreeViewAdvResourceImage("FolderClosed", "SQ", Color.Blue);

                    DcmItemSequence sq = di as DcmItemSequence;
                    foreach (DcmItemSequenceItem item in sq.SequenceItems) {
                        icon = LoadTreeViewAdvResourceImage("Folder", "", Color.Black);
                        DicomTagNode din = new DicomTagNode(icon, DicomTags.Item, item.StreamLength);
                        dn.Nodes.Add(din);
                        LoadDataset(item.Dataset, din.Nodes);
                        if (item.StreamLength == 0xffffffff) {
                            icon = LoadTreeViewAdvResourceImage("FolderClosed", "", Color.Black);
                            din.Nodes.Add(new DicomTagNode(icon, DicomTags.ItemDelimitationItem, 0));
                        }
                    }
                    if (sq.StreamLength == 0xffffffff) {
                        icon = LoadTreeViewAdvResourceImage("FolderClosed", "", Color.Black);
                        dn.Nodes.Add(new DicomTagNode(icon, DicomTags.SequenceDelimitationItem, 0));
                    }
                }
            }
        }

		public static XDocument ToXML(DcmDataset dataset, XDicomOptions options) {
			XDocument document = new XDocument(new XDeclaration("1.0", "utf-8", "yes"));
			XElement root = new XElement("dicom");
			LoadSequence(root, dataset.Elements, options);
			document.Add(root);
			return document;
		}

		public DcmPixelData(DcmDataset dataset) {
			_transferSyntax = dataset.InternalTransferSyntax;
			_lossy = dataset.GetString(DicomTags.LossyImageCompression, "00") != "00";
			_lossyMethod = dataset.GetString(DicomTags.LossyImageCompressionMethod, String.Empty);
			_lossyRatio = dataset.GetString(DicomTags.LossyImageCompressionRatio, String.Empty);
			_frames = dataset.GetInt32(DicomTags.NumberOfFrames, 1);
			_width = dataset.GetUInt16(DicomTags.Columns, 0);
			_height = dataset.GetUInt16(DicomTags.Rows, 0);
			_bitsStored = dataset.GetUInt16(DicomTags.BitsStored, 0);
			_bitsAllocated = dataset.GetUInt16(DicomTags.BitsAllocated, 0);
			_highBit = dataset.GetUInt16(DicomTags.HighBit, (ushort)(_bitsStored - 1));
			_samplesPerPixel = dataset.GetUInt16(DicomTags.SamplesPerPixel, 0);
			_pixelRepresentation = dataset.GetUInt16(DicomTags.PixelRepresentation, 0);
			_planarConfiguration = dataset.GetUInt16(DicomTags.PlanarConfiguration, 0);
			_photometricInterpretation = dataset.GetString(DicomTags.PhotometricInterpretation, String.Empty);
			_rescaleSlope = dataset.GetDouble(DicomTags.RescaleSlope, 1.0);
			_rescaleIntercept = dataset.GetDouble(DicomTags.RescaleIntercept, 0.0);
			_pixelDataItem = dataset.GetItem(DicomTags.PixelData);

			_hasPixelPadding = dataset.Contains(DicomTags.PixelPaddingValue);
			if (_hasPixelPadding) {
				DcmElement elem = dataset.GetElement(DicomTags.PixelPaddingValue);
				if (elem is DcmUnsignedShort)
					_pixelPaddingValue = (elem as DcmUnsignedShort).GetValue();
				else if (elem is DcmSignedShort) {
					_pixelPaddingValue = (elem as DcmSignedShort).GetValue();
				} else
					_pixelPaddingValue = MinimumDataValue;
			}
		}

        private static Expression<Func<Study, bool>> FilterByModality(DcmDataset query)
        {
            Expression<Func<Study, bool>> allMatch = p => true;

            var studyQuery = query.GetElement(DicomTags.ModalitiesInStudy);

            if (studyQuery == null)
                return allMatch;

            var valueString = studyQuery.GetValueString();

            if (String.IsNullOrWhiteSpace(valueString))
                return allMatch;

            var modalities = valueString.Replace(@"\\", @"\").Split('\\');

            if (modalities.Length == 1)
            {
                return s => s.ModalityAggregation.Contains(modalities[0]);
            }
            else
            {
                return s => s.Series.Any( series => modalities.Contains(series.PerformedModalityType));
            }
        }

 public static IPipeline Create(DcmDataset dataset, DcmPixelData pixelData)
 {
     PhotometricInterpretation pi = PhotometricInterpretation.Lookup(pixelData.PhotometricInterpretation);
     if (pi == PhotometricInterpretation.Monochrome1 || pi == PhotometricInterpretation.Monochrome2) {
         GenericGrayscalePipeline pipeline = new GenericGrayscalePipeline(pixelData.RescaleSlope, pixelData.RescaleIntercept, pixelData.BitsStored, pixelData.IsSigned);
         if (pi == PhotometricInterpretation.Monochrome1)
             pipeline.ColorMap = ColorTable.Monochrome1;
         else
             pipeline.ColorMap = ColorTable.Monochrome2;
         WindowLevel[] wl = WindowLevel.FromDataset(dataset);
         if (wl.Length > 0)
             pipeline.WindowLevel = wl[0];
         return pipeline;
     }
     else if (pi == PhotometricInterpretation.Rgb)
     {
         return new RgbColorPipeline();
     }
     else if (pi == PhotometricInterpretation.YbrFull || pi == PhotometricInterpretation.YbrFull422)
     {
         return new RgbColorPipeline();
     }
     else
     {
         throw new DicomImagingException("Unsupported pipeline photometric interpretation: {0}", pi.Value);
     }
 }

 public bool Match(DcmDataset dataset)
 {
     if (dataset.Contains(_tag)) {
         string value = dataset.GetValueString(_tag);
         return value.Contains(_value);
     }
     return false;
 }

		public void Transform(DcmDataset dataset) {
			if (_conditions != null)
				if (!_conditions.Match(dataset))
					return;

			foreach (IDicomTransformRule rule in _transformRules)
				rule.Transform(dataset);
		}

 private void Load(DcmDataset dataset, int frame)
 {
     Dataset = dataset;
     if (Dataset.InternalTransferSyntax.IsEncapsulated)
         Dataset.ChangeTransferSyntax(DicomTransferSyntax.ExplicitVRLittleEndian, null);
     DcmPixelData pixelData = new DcmPixelData(Dataset);
     _pixelData = PixelDataFactory.Create(pixelData, frame);
     _pipeline = PipelineFactory.Create(Dataset, pixelData);
     pixelData.Unload();
 }

        /// <summary>
        /// Initializes new Basic Film Session
        /// </summary>
        /// <param name="sessionClass">Color or Grayscale Basic Print Management UID</param>
        /// <param name="sopInstance">SOP Instance UID</param>
        /// <param name="dataset">Dataset</param>
        public DcmFilmSession(DicomUID sessionClass, DicomUID sopInstance, DcmDataset dataset)
        {
            _sessionClass = sessionClass;
            _sopInstance = sopInstance;
            _dataset = dataset;
            _boxes = new List<DcmFilmBox>();

            if (_sopInstance == null || _sopInstance.UID == String.Empty)
                _sopInstance = DicomUID.Generate();
        }

		/// <summary>
		/// Initializes new DICOM file format from dataset
		/// </summary>
		/// <param name="dataset">Dataset</param>
		public DicomFileFormat(DcmDataset dataset) {
			_metainfo = new DcmFileMetaInfo();
			_metainfo.FileMetaInformationVersion = DcmFileMetaInfo.Version;
			_metainfo.MediaStorageSOPClassUID = dataset.GetUID(DicomTags.SOPClassUID);
			_metainfo.MediaStorageSOPInstanceUID = dataset.GetUID(DicomTags.SOPInstanceUID);
			_metainfo.TransferSyntax = dataset.InternalTransferSyntax;
			_metainfo.ImplementationClassUID = Implementation.ClassUID;
			_metainfo.ImplementationVersionName = Implementation.Version;
			_metainfo.SourceApplicationEntityTitle = "";
			_dataset = dataset;
		}

        public static IQueryable<Series> GetMatchingSeries(MedicalISDataContext database, DcmDataset query)
        {
            var series = from s in database.Series select s;

            series = series.Where( FilterByStudyUid(query) );
            series = series.Where( FilterBySeriesUid(query) );
            series = series.Where( FilterBySeriesDate(query) );

            series.OrderBy(s => s.PerformedDateTime);

            return series;
        }

        private static Expression<Func<Patient, bool>> FilterByPatientsName(DcmDataset query)
        {
            Expression<Func<Patient, bool>> allMatch = p => true;

            var patientNameQuery = query.GetElement(DicomTags.PatientsName);

            if (patientNameQuery == null)
                return allMatch;

            var patientNameDicomFormatted = patientNameQuery.GetValueString();

            if (String.IsNullOrWhiteSpace(patientNameDicomFormatted))
                return allMatch;

            string[] lName;

            if (patientNameDicomFormatted.Contains("[^]"))
                lName = patientNameDicomFormatted.Split(new[] { "[^]" }, StringSplitOptions.None);
            else if (patientNameDicomFormatted.Contains("^"))
                lName = patientNameDicomFormatted.Split(new[] { "^" }, StringSplitOptions.None);
            else
                lName = patientNameDicomFormatted.Split(new[] { Properties.Settings.Default.PatientNameSplitCharacterForFind });

            var firstName = "";
            var lastName = "";

            if (lName.Length == 0)
                return allMatch;

            if (lName.Length >= 2)
            {
                firstName = lName[1];
                firstName = firstName.TrimEnd('*').Trim();
                firstName = firstName.Replace('*', '%');
            }

            if (lName.Length >= 1)
            {
                lastName = lName[0];
                lastName = lastName.TrimEnd('*').Trim();
                lastName = lastName.Replace('*', '%');
            }

            if (!firstName.StartsWith("\""))
                firstName += "%";
            if (!lastName.StartsWith("\""))
                lastName += "%";

            return p => SqlMethods.Like(p.FirstName, firstName) && SqlMethods.Like(p.LastName, lastName);
        }

        public void Decode(DcmDataset dataset, DcmPixelData oldPixelData, DcmPixelData newPixelData, DcmCodecParameters parameters)
        {
            DcmRleCodecParameters rleParams = parameters as DcmRleCodecParameters;

            if (rleParams == null)
                rleParams = GetDefaultParameters() as DcmRleCodecParameters;

            int pixelCount = oldPixelData.ImageWidth * oldPixelData.ImageHeight;
            int numberOfSegments = oldPixelData.BytesAllocated * oldPixelData.SamplesPerPixel;

            byte[] frameData = new byte[newPixelData.UncompressedFrameSize];

            for (int i = 0; i < oldPixelData.NumberOfFrames; i++)
            {
                IList<ByteBuffer> rleData = oldPixelData.GetFrameFragments(i);
                RLEDecoder decoder = new RLEDecoder(rleData);

                if (decoder.NumberOfSegments != numberOfSegments)
                    throw new DicomCodecException("Unexpected number of RLE segments!");

                for (int s = 0; s < numberOfSegments; s++)
                {
                    int sample = s / newPixelData.BytesAllocated;
                    int sabyte = s % newPixelData.BytesAllocated;

                    int pos, offset;

                    if (newPixelData.PlanarConfiguration == 0)
                    {
                        pos = sample * newPixelData.BytesAllocated;
                        offset = newPixelData.SamplesPerPixel * newPixelData.BytesAllocated;
                    }
                    else
                    {
                        pos = sample * newPixelData.BytesAllocated * pixelCount;
                        offset = newPixelData.BytesAllocated;
                    }

                    if (rleParams.ReverseByteOrder)
                        pos += sabyte;
                    else
                        pos += newPixelData.BytesAllocated - sabyte - 1;

                    decoder.DecodeSegment(s, frameData, pos, offset);
                }

                newPixelData.AddFrame(frameData);
            }
        }

        public static IQueryable<Patient> GetMatchingPatients(MedicalISDataContext database, DcmDataset query, bool anonymousOnly = false)
        {
            var patients = from p in database.Patients select p;

            if( anonymousOnly == false )
                patients = patients.Where(FilterByPatientsName(query));

            patients = patients.Where(FilterByPatientsId(query));
            patients = patients.Where(FilterByPatientsBirthDate(query));
            patients = patients.Where(FilterByStudyPerformedDate(query));
            patients = patients.Where(FilterByStudyModalityDate(query));

            patients = patients.OrderByDescending(p => p.Studies.Max(s => s.PerformedDateTime));

            return patients;
        }

		public bool Match(DcmDataset dataset) {
			if (_operator == DicomMatchOperator.Or) {
				foreach (IDicomMatchRule rule in _rules)
					if (rule.Match(dataset))
						return true;

				return false;
			}
			else {
				foreach (IDicomMatchRule rule in _rules)
					if (!rule.Match(dataset))
						return false;

				return true;
			}
		}

        private static Expression<Func<Series, bool>> FilterBySeriesDate(DcmDataset query)
        {
            Expression<Func<Series, bool>> allMatch = p => true;

            var studyQuery = query.GetElement(DicomTags.SeriesDate);

            if (studyQuery == null)
                return allMatch;

            var valueString = studyQuery.GetValueString();

            if (String.IsNullOrWhiteSpace(valueString))
                return allMatch;

            var dateTimeRange = DateTimeRangeQuery.Parse(valueString);

            return s => s.PerformedDateTime >= dateTimeRange.From && s.PerformedDateTime <= dateTimeRange.To;
        }

        private static Expression<Func<Study, bool>> FilterByPatientsBirthDate(DcmDataset query)
        {
            Expression<Func<Study, bool>> allMatch = p => true;

            var patientQuery = query.GetElement(DicomTags.PatientsBirthDate);

            if (patientQuery == null)
                return allMatch;

            var valueString = patientQuery.GetValueString();

            if (String.IsNullOrWhiteSpace(valueString))
                return allMatch;

            var dateTimeRange = DateTimeRangeQuery.Parse(valueString);

            return s => s.Patient.BirthDateTime >= dateTimeRange.From && s.Patient.BirthDateTime <= dateTimeRange.To;
        }