public ImagePlaneAnnotationItemProvider()
			: base("AnnotationItemProviders.Dicom.ImagePlane", new AnnotationResourceResolver(typeof(ImagePlaneAnnotationItemProvider).Assembly))
		{
			_annotationItems = new List<IAnnotationItem>();

			AnnotationResourceResolver resolver = new AnnotationResourceResolver(this);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.ImagePlane.SliceThickness",
						resolver,
						delegate(Frame frame)
						{
							double thickness = frame.SliceThickness;

							if (double.IsNaN(thickness) || thickness == 0)
								return "";

							return String.Format(SR.FormatMillimeters, frame.SliceThickness.ToString("F1"));
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add(new SliceLocationAnnotationItem());
		}
		public ContrastBolusAnnotationItemProvider()
			: base("AnnotationItemProviders.Dicom.ContrastBolus", new AnnotationResourceResolver(typeof (ContrastBolusAnnotationItemProvider).Assembly))
		{
			_annotationItems = new List<IAnnotationItem>();

			AnnotationResourceResolver resolver = new AnnotationResourceResolver(this);

			_annotationItems.Add
				(
					new CodeSequenceAnnotationItem
						(
						"Dicom.ContrastBolus.Agent",
						resolver,
						DicomTags.ContrastBolusAgentSequence,
						DicomTags.ContrastBolusAgent
						)
				);

			// N.B.: The contrast/bolus items defined here are only for those that are defined as part of (enhanced) contrast/bolus module C.7.6.4 and C.7.6.4b
			// Annotation items for contrast/bolus tags in the X-Ray 3D Shared Acquisition macro should be defined separately in the DX or another X-Ray specific provider
		}
예제 #3
0
		public MRImageAnnotationItemProvider()
			: base("AnnotationItemProviders.Dicom.MRImage", new AnnotationResourceResolver(typeof(MRImageAnnotationItemProvider).Assembly))
		{
			_annotationItems = new List<IAnnotationItem>();

			AnnotationResourceResolver resolver = new AnnotationResourceResolver(this);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.MRImage.EchoTime",
						resolver,
						delegate(Frame frame)
						{
							double value;
							bool tagExists = frame.ParentImageSop[DicomTags.EchoTime].TryGetFloat64(0, out value);
							if (tagExists)
								return String.Format(SR.FormatMilliseconds, value.ToString("F2"));

							return "";
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.MRImage.MagneticFieldStrength",
						resolver,
						delegate(Frame frame)
						{
							double value;
							bool tagExists = frame.ParentImageSop[DicomTags.MagneticFieldStrength].TryGetFloat64(0, out value);
							if (tagExists)
								return String.Format(SR.FormatTeslas, value.ToString("F1"));

							return "";
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.MRImage.AcquisitionMatrix",
						resolver,
						delegate(Frame frame)
						{
							//TODO (CR Mar 2010): check for the 2 that aren't zero.
							string phaseDirection = frame.ParentImageSop[DicomTags.InPlanePhaseEncodingDirection].ToString().ToUpperInvariant();

							DicomAttribute acqAttrib = frame.ParentImageSop[DicomTags.AcquisitionMatrix];
							if (!acqAttrib.IsEmpty && acqAttrib.Count > 3)
							{
								ushort frequencyRows = acqAttrib.GetUInt16(0, 0);
								ushort frequencyColumns = acqAttrib.GetUInt16(1, 0);
								ushort phaseRows = acqAttrib.GetUInt16(2, 0);
								ushort phaseColumns = acqAttrib.GetUInt16(3, 0);

								switch (phaseDirection)
								{
									case "COL":
										return String.Format(SR.Format2Dimensions, phaseColumns, frequencyRows);
									case "ROW":
									default:
										return String.Format(SR.Format2Dimensions, frequencyColumns, phaseRows);
								}
							}

							return "";
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.MRImage.ReceiveCoilName",
						resolver,
						delegate(Frame frame)
						{
							string value;
							value = frame.ParentImageSop[DicomTags.ReceiveCoilName].GetString(0, null);
							return value;
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.MRImage.RepetitionTime",
						resolver,
						delegate(Frame frame)
						{
							double value;
							bool tagExists = frame.ParentImageSop[DicomTags.RepetitionTime].TryGetFloat64(0, out value);
							if (tagExists)
								return String.Format(SR.FormatMilliseconds, value.ToString("F2"));

							return "";
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.MRImage.EchoTrainLength",
						resolver,
						delegate(Frame frame)
						{
							int value;
							bool tagExists = frame.ParentImageSop[DicomTags.EchoTrainLength].TryGetInt32(0, out value);
							if (tagExists)
								return String.Format("{0}", value);

							return "";
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.MRImage.InversionTime",
						resolver,
						delegate(Frame frame)
						{
							double value;
							var tagExists = frame.ParentImageSop[DicomTags.InversionTime].TryGetFloat64(0, out value);
							return tagExists ? string.Format(SR.FormatMilliseconds, value.ToString("F2")) : string.Empty;
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.MRImage.TriggerTime",
						resolver,
						delegate(Frame frame)
						{
							double value;
							var tagExists = frame.ParentImageSop[DicomTags.TriggerTime].TryGetFloat64(0, out value);
							return tagExists ? string.Format(SR.FormatMilliseconds, value.ToString("F2")) : string.Empty;
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.MRImage.NumberOfAverages",
						resolver,
						delegate(Frame frame)
						{
							double value;
							var tagExists = frame.ParentImageSop[DicomTags.NumberOfAverages].TryGetFloat64(0, out value);
							return tagExists ? string.Format("{0}", value) : string.Empty;
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.MRImage.PixelBandwidth",
						resolver,
						delegate(Frame frame)
						{
							double value;
							var tagExists = frame.ParentImageSop[DicomTags.PixelBandwidth].TryGetFloat64(0, out value);
							return tagExists ? string.Format(SR.FormatHertzPerPixel, value.ToString("F2")) : string.Empty;
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.MRImage.FlipAngle",
						resolver,
						delegate(Frame frame)
						{
							double value;
							var tagExists = frame.ParentImageSop[DicomTags.FlipAngle].TryGetFloat64(0, out value);
							return tagExists ? string.Format(SR.FormatDegrees, value.ToString("F2")) : string.Empty;
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);
		}
		public CTImageAnnotationItemProvider()
			: base("AnnotationItemProviders.Dicom.CTImage", new AnnotationResourceResolver(typeof (CTImageAnnotationItemProvider).Assembly))
		{
			_annotationItems = new List<IAnnotationItem>();

			AnnotationResourceResolver resolver = new AnnotationResourceResolver(this);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.CTImage.KVP",
						resolver,
						delegate(Frame frame)
							{
								double value;
								bool tagExists = frame[DicomTags.Kvp].TryGetFloat64(0, out value);
								if (tagExists)
									return String.Format(SR.FormatKilovolts, value);

								return "";
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.CTImage.XRayTubeCurrent",
						resolver,
						f => DXImageAnnotationItemProvider.GetXRayTubeCurrentInMa(f, SR.FormatMilliamps),
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.CTImage.GantryDetectorTilt",
						resolver,
						delegate(Frame frame)
							{
								double value;
								bool tagExists = frame[DicomTags.GantryDetectorTilt].TryGetFloat64(0, out value);
								if (tagExists)
									return String.Format(SR.FormatDegrees, value);

								return "";
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.CTImage.Exposure",
						resolver,
						f => DXImageAnnotationItemProvider.GetExposureInMas(f, SR.FormatMilliampSeconds),
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.CTImage.ExposureTime",
						resolver,
						f => DXImageAnnotationItemProvider.GetExposureTimeInMs(f, SR.FormatMilliseconds),
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.CTImage.ConvolutionKernel",
						resolver,
						frame => frame[DicomTags.ConvolutionKernel].GetString(0, null),
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.CTImage.TableSpeed",
						resolver,
						GetTableSpeed,
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.CTImage.TablePosition",
						resolver,
						GetTablePosition,
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.CTImage.Composite.TablePositionSpeed",
						resolver,
						delegate(Frame frame)
							{
								var position = GetTablePosition(frame);
								var speed = GetTableSpeed(frame);
								if (string.IsNullOrEmpty(position))
									return speed;
								if (string.IsNullOrEmpty(speed))
									return position;
								return string.Format(SR.FormatTablePositionSpeed, position, speed);
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);
		}
		public DXImageAnnotationItemProvider()
			: base("AnnotationItemProviders.Dicom.DXImage", new AnnotationResourceResolver(typeof (DXImageAnnotationItemProvider).Assembly))
		{
			_annotationItems = new List<IAnnotationItem>();

			AnnotationResourceResolver resolver = new AnnotationResourceResolver(this);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this is actually DX Positioning module
					"Dicom.DXImage.DetectorPrimaryAngle",
					resolver,
					f => FormatFloat64(f, DicomTags.DetectorPrimaryAngle, SR.FormatDegrees),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this is actually DX Positioning module
					"Dicom.DXImage.PositionerPrimaryAngle",
					resolver,
					f => FormatFloat64(f, DicomTags.PositionerPrimaryAngle, SR.FormatDegrees),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this is actually DX Positioning module
					"Dicom.DXImage.PositionerSecondaryAngle",
					resolver,
					f => FormatFloat64(f, DicomTags.PositionerSecondaryAngle, SR.FormatDegrees),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this is actually DX Positioning module
					"Dicom.DXImage.BodyPartThickness",
					resolver,
					f => string.Format(SR.FormatMillimeters, FormatFloat64(f, DicomTags.BodyPartThickness, "{0:F1}")),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this is actually DX Positioning module
					"Dicom.DXImage.CompressionForce",
					resolver,
					f => FormatInt32(f, DicomTags.CompressionForce, SR.FormatNewtons),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this is actually DX Series module
					"Dicom.DXImage.PresentationIntentType",
					resolver,
					f => f.ParentImageSop[DicomTags.PresentationIntentType].ToString(),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// whoa, this is actually DX Image module
					"Dicom.DXImage.AcquisitionDeviceProcessingDescription",
					resolver,
					f => f.ParentImageSop[DicomTags.AcquisitionDeviceProcessingDescription].ToString(),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this is actually DX Detector module
					"Dicom.DXImage.CassetteId",
					resolver,
					f => f.ParentImageSop[DicomTags.CassetteId].ToString(),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this is actually DX Detector module
					"Dicom.DXImage.PlateId",
					resolver,
					f => f.ParentImageSop[DicomTags.PlateId].ToString(),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this isn't even a DX module, but other X-Ray related modules
					"Dicom.DXImage.KVP",
					resolver,
					f => FormatFloat64(f, DicomTags.Kvp, SR.FormatKilovolts),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this isn't even a DX module, but other X-Ray related modules
					"Dicom.DXImage.AveragePulseWidth",
					resolver,
					f => FormatFloat64(f, DicomTags.AveragePulseWidth, SR.FormatMilliseconds),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this isn't even a DX module, but other X-Ray related modules
					"Dicom.DXImage.ImageAndFluoroscopyAreaDoseProduct",
					resolver,
					f => FormatFloat64(f, DicomTags.ImageAndFluoroscopyAreaDoseProduct, SR.FormatDecigraySquareCentimeters),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// legacy item (new layouts should use Exposure) so that current annotation layouts don't break - can be removed in a future release
					"Dicom.DXImage.ExposureInMas",
					resolver,
					f => GetExposureInMas(f, SR.FormatMilliampSeconds),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this isn't defined in a DX module, but rather in other X-Ray related modules
					"Dicom.DXImage.Exposure",
					resolver,
					f => GetExposureInMas(f, SR.FormatMilliampSeconds),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this isn't defined in a DX module, but rather in other X-Ray related modules
					"Dicom.DXImage.ExposureTime",
					resolver,
					f => GetExposureTimeInMs(f, SR.FormatMilliseconds),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this isn't defined in a DX module, but rather in other X-Ray related modules
					"Dicom.DXImage.XRayTubeCurrent",
					resolver,
					f => GetXRayTubeCurrentInMa(f, SR.FormatMilliamps),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					// this isn't even a DX module, but other X-Ray related modules
					"Dicom.DXImage.FilterMaterial",
					resolver,
					f => f.ParentImageSop[DicomTags.FilterMaterial].ToString(),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new CodeSequenceAnnotationItem
					(
					// this isn't even a DX module, but other X-Ray related modules
					"Dicom.DXImage.ContrastBolusAgent",
					resolver,
					DicomTags.ContrastBolusAgentSequence,
					DicomTags.ContrastBolusAgent
					)
				);
		}
		public DXImageAnnotationItemProvider()
			: base("AnnotationItemProviders.Dicom.DXImage", new AnnotationResourceResolver(typeof (DXImageAnnotationItemProvider).Assembly))
		{
			_annotationItems = new List<IAnnotationItem>();
			_frameContext = new AnnotationDataSourceContext<Frame>();
			_frameContext.DataSourceChanged += OnFrameContextDataSourceChanged;

			AnnotationResourceResolver resolver = new AnnotationResourceResolver(this);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this is actually DX Positioning module
						"Dicom.DXImage.DetectorPrimaryAngle",
						resolver,
						f => FormatFloat64(f, DicomTags.DetectorPrimaryAngle, SR.FormatDegrees),
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this is actually DX Positioning module
						"Dicom.DXImage.PositionerPrimaryAngle",
						resolver,
						f => FormatFloat64(f, DicomTags.PositionerPrimaryAngle, SR.FormatDegrees),
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this is actually DX Positioning module
						"Dicom.DXImage.PositionerSecondaryAngle",
						resolver,
						f => FormatFloat64(f, DicomTags.PositionerSecondaryAngle, SR.FormatDegrees),
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this is actually DX Positioning or X-Ray 3D Acquisition module
						"Dicom.DXImage.BodyPartThickness",
						resolver,
						f =>
							{
								var acquisitions = _frameContext.GetData<IXRay3DAcquisitionSequenceItem[]>(f, _keyAcquisitionSequence);
								var dataset = acquisitions != null ? (IEnumerable<IDicomAttributeProvider>) acquisitions.Select(a => a.DicomSequenceItem) : new IDicomAttributeProvider[] {f};
								return string.Format(SR.FormatMillimeters, FormatMultiValues(dataset, FormatFloat64, DicomTags.BodyPartThickness, "{0:F1}"));
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this is actually DX Positioning module
						"Dicom.DXImage.CompressionForce",
						resolver,
						f =>
							{
								var acquisitions = _frameContext.GetData<IXRay3DAcquisitionSequenceItem[]>(f, _keyAcquisitionSequence);
								var dataset = acquisitions != null ? (IEnumerable<IDicomAttributeProvider>) acquisitions.Select(a => a.DicomSequenceItem) : new IDicomAttributeProvider[] {f};
								return FormatMultiValues(dataset, FormatInt32, DicomTags.CompressionForce, SR.FormatNewtons);
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this is actually DX Series module
						"Dicom.DXImage.PresentationIntentType",
						resolver,
						f => f[DicomTags.PresentationIntentType].ToString(),
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// whoa, this is actually DX Image module
						"Dicom.DXImage.AcquisitionDeviceProcessingDescription",
						resolver,
						f => f[DicomTags.AcquisitionDeviceProcessingDescription].ToString(),
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this is actually DX Detector module
						"Dicom.DXImage.CassetteId",
						resolver,
						f => f[DicomTags.CassetteId].ToString(),
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this is actually DX Detector module
						"Dicom.DXImage.PlateId",
						resolver,
						f => f[DicomTags.PlateId].ToString(),
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this isn't even a DX module, but other X-Ray related modules
						"Dicom.DXImage.KVP",
						resolver,
						f =>
							{
								var acquisitions = _frameContext.GetData<IXRay3DAcquisitionSequenceItem[]>(f, _keyAcquisitionSequence);
								var dataset = acquisitions != null ? (IEnumerable<IDicomAttributeProvider>) acquisitions.Select(a => a.DicomSequenceItem) : new IDicomAttributeProvider[] {f};
								return FormatMultiValues(dataset, FormatFloat64, DicomTags.Kvp, SR.FormatKilovolts);
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this isn't even a DX module, but other X-Ray related modules
						"Dicom.DXImage.AveragePulseWidth",
						resolver,
						f => FormatFloat64(f, DicomTags.AveragePulseWidth, SR.FormatMilliseconds),
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this isn't even a DX module, but other X-Ray related modules
						"Dicom.DXImage.ImageAndFluoroscopyAreaDoseProduct",
						resolver,
						f => FormatFloat64(f, DicomTags.ImageAndFluoroscopyAreaDoseProduct, SR.FormatDecigraySquareCentimeters),
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// legacy item (new layouts should use Exposure) so that current annotation layouts don't break - can be removed in a future release
						"Dicom.DXImage.ExposureInMas",
						resolver,
						f =>
							{
								var acquisitions = _frameContext.GetData<IXRay3DAcquisitionSequenceItem[]>(f, _keyAcquisitionSequence);
								var dataset = acquisitions != null ? (IEnumerable<IDicomAttributeProvider>) acquisitions.Select(a => a.DicomSequenceItem) : new IDicomAttributeProvider[] {f};
								return FormatMultiValues(dataset, GetExposureInMas, SR.FormatMilliampSeconds);
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this isn't defined in a DX module, but rather in other X-Ray related modules
						"Dicom.DXImage.Exposure",
						resolver,
						f =>
							{
								var acquisitions = _frameContext.GetData<IXRay3DAcquisitionSequenceItem[]>(f, _keyAcquisitionSequence);
								var dataset = acquisitions != null ? (IEnumerable<IDicomAttributeProvider>) acquisitions.Select(a => a.DicomSequenceItem) : new IDicomAttributeProvider[] {f};
								return FormatMultiValues(dataset, GetExposureInMas, SR.FormatMilliampSeconds);
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this isn't defined in a DX module, but rather in other X-Ray related modules
						"Dicom.DXImage.ExposureTime",
						resolver,
						f =>
							{
								var acquisitions = _frameContext.GetData<IXRay3DAcquisitionSequenceItem[]>(f, _keyAcquisitionSequence);
								var dataset = acquisitions != null ? (IEnumerable<IDicomAttributeProvider>) acquisitions.Select(a => a.DicomSequenceItem) : new IDicomAttributeProvider[] {f};
								return FormatMultiValues(dataset, GetExposureTimeInMs, SR.FormatMilliseconds);
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this isn't defined in a DX module, but rather in other X-Ray related modules
						"Dicom.DXImage.XRayTubeCurrent",
						resolver,
						f =>
							{
								var acquisitions = _frameContext.GetData<IXRay3DAcquisitionSequenceItem[]>(f, _keyAcquisitionSequence);
								var dataset = acquisitions != null ? (IEnumerable<IDicomAttributeProvider>) acquisitions.Select(a => a.DicomSequenceItem) : new IDicomAttributeProvider[] {f};
								return FormatMultiValues(dataset, GetXRayTubeCurrentInMa, SR.FormatMilliamps);
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						// this isn't even a DX module, but other X-Ray related modules
						"Dicom.DXImage.FilterMaterial",
						resolver,
						f =>
							{
								var acquisitions = _frameContext.GetData<IXRay3DAcquisitionSequenceItem[]>(f, _keyAcquisitionSequence);
								var dataset = acquisitions != null ? (IEnumerable<IDicomAttributeProvider>) acquisitions.Select(a => a.DicomSequenceItem) : new IDicomAttributeProvider[] {f};
								return FormatMultiValues(dataset, FormatString, DicomTags.FilterMaterial, null);
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new CodeSequenceAnnotationItem
						(
						// definition of the contrast/bolus agent item takes into account the X-Ray 3D Acquisition sequence, and is thus separate from the normal contast/bolus modules
						"Dicom.DXImage.ContrastBolusAgent",
						resolver,
						DicomTags.ContrastBolusAgentSequence,
						DicomTags.ContrastBolusAgent,
						f =>
							{
								var acquisitions = _frameContext.GetData<IXRay3DAcquisitionSequenceItem[]>(f, _keyAcquisitionSequence);
								return acquisitions != null ? (IDicomAttributeProvider) acquisitions.Select(d => d.DicomSequenceItem).FirstOrDefault() : f;
							}
						)
				);
		}
		public PatientAnnotationItemProvider()
			: base("AnnotationItemProviders.Dicom.Patient", new AnnotationResourceResolver(typeof(PatientAnnotationItemProvider).Assembly))
		{
			_annotationItems = new List<IAnnotationItem>();

			AnnotationResourceResolver resolver = new AnnotationResourceResolver(this);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.EthnicGroup",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.EthnicGroup),
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.PatientComments",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.PatientComments),
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.PatientId",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.PatientId; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.PatientsBirthDate",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.PatientsBirthDate; },
						DicomDataFormatHelper.DateFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.PatientsBirthTime",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.PatientsBirthTime),
						DicomDataFormatHelper.TimeFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<PersonName>
					(
						"Dicom.Patient.PatientsName",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.PatientsName; },
						DicomDataFormatHelper.PersonNameFormatter
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.PatientsSex",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.PatientsSex; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<PersonName>
					(
						"Dicom.Patient.ResponsiblePerson",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.ResponsiblePerson; },
						DicomDataFormatHelper.PersonNameFormatter
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.ResponsibleOrganization",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.ResponsibleOrganization; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new CodeSequenceAnnotationItem
					(
						"Dicom.Patient.PatientSpecies",
						resolver,
						DicomTags.PatientSpeciesCodeSequence,
						DicomTags.PatientSpeciesDescription
					)
				);

			_annotationItems.Add
				(
					new CodeSequenceAnnotationItem
					(
						"Dicom.Patient.PatientBreed",
						resolver,
						DicomTags.PatientBreedCodeSequence,
						DicomTags.PatientBreedDescription
					)
				);
		}
		public GeneralStudyAnnotationItemProvider()
			: base("AnnotationItemProviders.Dicom.GeneralStudy", new AnnotationResourceResolver(typeof(GeneralStudyAnnotationItemProvider).Assembly))
		{
			_annotationItems = new List<IAnnotationItem>();

			AnnotationResourceResolver resolver = new AnnotationResourceResolver(this);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralStudy.AccessionNumber",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.AccessionNumber; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<PersonName>
					(
						"Dicom.GeneralStudy.ReferringPhysiciansName",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.ReferringPhysiciansName; },
						DicomDataFormatHelper.PersonNameFormatter
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralStudy.StudyDate",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.StudyDate; },
						DicomDataFormatHelper.DateFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralStudy.StudyTime",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.StudyTime; },
						DicomDataFormatHelper.TimeFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralStudy.StudyDescription",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.StudyDescription; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralStudy.StudyId",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.StudyId),
						DicomDataFormatHelper.RawStringFormat
					)
				);
		}
		public GeneralImageAnnotationItemProvider()
			: base("AnnotationItemProviders.Dicom.GeneralImage", new AnnotationResourceResolver(typeof(GeneralImageAnnotationItemProvider).Assembly))
		{
			_annotationItems = new List<IAnnotationItem>();

			AnnotationResourceResolver resolver = new AnnotationResourceResolver(this);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralImage.AcquisitionDate",
						resolver,
						delegate(Frame frame) { return frame.AcquisitionDate; },
						DicomDataFormatHelper.DateFormat
					)
				);


			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralImage.AcquisitionTime",
						resolver,
						delegate(Frame frame) { return frame.AcquisitionTime; },
						delegate (string input)
							{
								if (String.IsNullOrEmpty(input))
									return String.Empty;

								DateTime time;
								if (!TimeParser.Parse(input, out time))
									return input;

								return time.ToString("HH:mm:ss.FFFFFF");
							}
					)
				);


			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralImage.AcquisitionDateTime",
						resolver,
						delegate(Frame frame) { return frame.AcquisitionDateTime; },
						delegate(string input)
							{
								if (String.IsNullOrEmpty(input))
									return String.Empty;

								DateTime dateTime;
								if (!DateTimeParser.Parse(input, out dateTime))
									return input;

								return String.Format("{0} {1}", 
									dateTime.Date.ToString(Format.DateFormat),
									dateTime.ToString("HH:mm:ss.FFFFFF"));
							}
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralImage.AcquisitionNumber",
						resolver,
						delegate(Frame frame) { return frame.AcquisitionNumber.ToString(); },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
						"Dicom.GeneralImage.ContentDate",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.ContentDate),
						DicomDataFormatHelper.DateFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralImage.ContentTime",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.ContentTime),
						DicomDataFormatHelper.TimeFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralImage.DerivationDescription",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.DerivationDescription),
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralImage.ImageComments",
						resolver,
						delegate(Frame frame) { return frame.ImageComments; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralImage.ImagesInAcquisition",
						resolver,
						delegate(Frame frame) { return frame.ImagesInAcquisition.ToString(); },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralImage.ImageType",
						resolver,
						delegate(Frame frame) { return frame.ImageType; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add(new InstanceNumberAnnotationItem());

			_annotationItems.Add
				(
					new LossyImagePresentationAnnotationItem
					(
						"Dicom.GeneralImage.LossyImageCompression",
						resolver
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralImage.QualityControlImage",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.QualityControlImage),
						DicomDataFormatHelper.BooleanFormatter
					)
				);

			_annotationItems.Add
				(
					new LateralityViewPositionAnnotationItem
					(
						"Dicom.GeneralImage.ViewPosition",
						false, true
					)
				);

			_annotationItems.Add
				(
					new LateralityViewPositionAnnotationItem
					(
						"Dicom.GeneralImage.ImageLaterality",
						true, false
					)
				);
			
			_annotationItems.Add
				(
					new LateralityViewPositionAnnotationItem
					(
						"Dicom.GeneralImage.Composite.LateralityViewPosition",
						true, true
					)
				);
		}
		public GeneralSeriesAnnotationItemProvider()
			: base("AnnotationItemProviders.Dicom.GeneralSeries", new AnnotationResourceResolver(typeof(GeneralSeriesAnnotationItemProvider).Assembly))
		{
			_annotationItems = new List<IAnnotationItem>();

			AnnotationResourceResolver resolver = new AnnotationResourceResolver(this);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralSeries.BodyPartExamined",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.BodyPartExamined; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralSeries.Laterality",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.Laterality; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralSeries.Modality",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.Modality; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<PersonName[]>
					(
						"Dicom.GeneralSeries.OperatorsName",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.OperatorsName; },
						DicomDataFormatHelper.PersonNameListFormatter
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralSeries.PerformedProcedureStepDescription",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.PerformedProcedureStepDescription),
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<PersonName[]>
					(
						"Dicom.GeneralSeries.PerformingPhysiciansName",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.PerformingPhysiciansName; },
						DicomDataFormatHelper.PersonNameListFormatter
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralSeries.ProtocolName",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.ProtocolName),
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralSeries.SeriesDate",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.SeriesDate; },
						DicomDataFormatHelper.DateFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralSeries.SeriesTime",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.SeriesTime; },
						DicomDataFormatHelper.TimeFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralSeries.SeriesDescription",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.SeriesDescription; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.GeneralSeries.SeriesNumber",
						resolver,
						delegate(Frame frame)
						{
							if (frame.ParentImageSop.ParentSeries != null)
							{
								return String.Format(SR.FormatSeriesNumberAndCount, frame.ParentImageSop.SeriesNumber, 
									frame.ParentImageSop.ParentSeries.ParentStudy.Series.Count);
							}
							else
							{
								return frame.ParentImageSop.SeriesNumber.ToString();
							}
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);
		}
		public GeneralEquipmentAnnotationItemProvider()
			: base("AnnotationItemProviders.Dicom.GeneralEquipment", new AnnotationResourceResolver(typeof (GeneralEquipmentAnnotationItemProvider).Assembly))
		{
			_annotationItems = new List<IAnnotationItem>();

			AnnotationResourceResolver resolver = new AnnotationResourceResolver(this);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					"Dicom.GeneralEquipment.DateOfLastCalibration",
					resolver,
					FrameDataRetrieverFactory.GetStringRetriever(DicomTags.DateOfLastCalibration),
					DicomDataFormatHelper.DateFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					"Dicom.GeneralEquipment.TimeOfLastCalibration",
					resolver,
					FrameDataRetrieverFactory.GetStringRetriever(DicomTags.TimeOfLastCalibration),
					DicomDataFormatHelper.TimeFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					"Dicom.GeneralEquipment.DeviceSerialNumber",
					resolver,
					FrameDataRetrieverFactory.GetStringRetriever(DicomTags.DeviceSerialNumber),
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					"Dicom.GeneralEquipment.InstitutionAddress",
					resolver,
					FrameDataRetrieverFactory.GetStringRetriever(DicomTags.InstitutionAddress),
					SingleLineStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					"Dicom.GeneralEquipment.InstitutionalDepartmentName",
					resolver,
					delegate(Frame frame) { return frame.ParentImageSop.InstitutionalDepartmentName; },
					SingleLineStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					"Dicom.GeneralEquipment.InstitutionName",
					resolver,
					delegate(Frame frame) { return frame.ParentImageSop.InstitutionName; },
					SingleLineStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					"Dicom.GeneralEquipment.Manufacturer",
					resolver,
					delegate(Frame frame) { return frame.ParentImageSop.Manufacturer; },
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					"Dicom.GeneralEquipment.ManufacturersModelName",
					resolver,
					delegate(Frame frame) { return frame.ParentImageSop.ManufacturersModelName; },
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string>
					(
					"Dicom.GeneralEquipment.StationName",
					resolver,
					delegate(Frame frame) { return frame.ParentImageSop.StationName; },
					DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
				new DicomAnnotationItem<string[]>
					(
					"Dicom.GeneralEquipment.SoftwareVersions",
					resolver,
					FrameDataRetrieverFactory.GetStringArrayRetriever(DicomTags.SoftwareVersions),
					DicomDataFormatHelper.StringListFormat
					)
				);
		}
		public PatientAnnotationItemProvider()
			: base("AnnotationItemProviders.Dicom.Patient", new AnnotationResourceResolver(typeof(PatientAnnotationItemProvider).Assembly))
		{
			_annotationItems = new List<IAnnotationItem>();

			AnnotationResourceResolver resolver = new AnnotationResourceResolver(this);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.EthnicGroup",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.EthnicGroup),
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.PatientComments",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.PatientComments),
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.PatientId",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.PatientId; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.OtherPatientIds",
						resolver,
						delegate(Frame frame)
							{
								var patientIds = new List<string>();
								DicomAttribute attribute;
								if (frame.ParentImageSop.TryGetAttribute(DicomTags.OtherPatientIds, out attribute))
									patientIds.AddRange(DicomStringHelper.GetStringArray(attribute));

								if (frame.ParentImageSop.TryGetAttribute(DicomTags.OtherPatientIdsSequence, out attribute) && !attribute.IsEmpty && !attribute.IsNull)
								{
									var sqAttr = (DicomAttributeSQ)attribute;
									for (var i = 0; i < sqAttr.Count; i++)
									{
										var attr = sqAttr[i][DicomTags.PatientId];
										if (attr != null && !string.IsNullOrEmpty(attr))
											patientIds.Add(attr);
									}
								}

								return DicomStringHelper.GetDicomStringArray(patientIds.Distinct());
							},
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.PatientsBirthDate",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.PatientsBirthDate; },
						DicomDataFormatHelper.DateFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.PatientsBirthTime",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.PatientsBirthTime),
						DicomDataFormatHelper.TimeFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<PersonName>
					(
						"Dicom.Patient.PatientsName",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.PatientsName; },
						DicomDataFormatHelper.PersonNameFormatter
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.PatientsSex",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.PatientsSex; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<PersonName>
					(
						"Dicom.Patient.ResponsiblePerson",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.ResponsiblePerson; },
						DicomDataFormatHelper.PersonNameFormatter
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.Patient.ResponsibleOrganization",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.ResponsibleOrganization; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new CodeSequenceAnnotationItem
					(
						"Dicom.Patient.PatientSpecies",
						resolver,
						DicomTags.PatientSpeciesCodeSequence,
						DicomTags.PatientSpeciesDescription
					)
				);

			_annotationItems.Add
				(
					new CodeSequenceAnnotationItem
					(
						"Dicom.Patient.PatientBreed",
						resolver,
						DicomTags.PatientBreedCodeSequence,
						DicomTags.PatientBreedDescription
					)
				);
		}
		public PatientStudyAnnotationItemProvider()
			: base("AnnotationItemProviders.Dicom.PatientStudy", new AnnotationResourceResolver(typeof(PatientStudyAnnotationItemProvider).Assembly))
		{
			_annotationItems = new List<IAnnotationItem>();

			AnnotationResourceResolver resolver = new AnnotationResourceResolver(this);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.PatientStudy.AdditionalPatientsHistory",
						resolver,
						delegate(Frame frame) { return frame.ParentImageSop.AdditionalPatientsHistory; },
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.PatientStudy.Occupation",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.Occupation),
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.PatientStudy.PatientsAge",
						resolver,
						FrameDataRetrieverFactory.GetStringRetriever(DicomTags.PatientsAge),
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<double>
					(
						"Dicom.PatientStudy.PatientsSize",
						resolver,
						FrameDataRetrieverFactory.GetDoubleRetriever(DicomTags.PatientsSize),
						delegate(double input)
						{
							if (double.IsNaN(input) || input == 0)
								return "";

							return String.Format(SR.FormatMeters, input.ToString("F2"));
						}
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<double>
					(
						"Dicom.PatientStudy.PatientsWeight",
						resolver,
						FrameDataRetrieverFactory.GetDoubleRetriever(DicomTags.PatientsWeight),
						delegate(double input)
						{
							if (double.IsNaN(input) || input == 0)
								return "";

							return String.Format(SR.FormatKilograms, input.ToString("F2"));
						}
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.PatientStudy.Composite.PatientsAgeSex",
						resolver,
						delegate(Frame frame)
						{
						    var components = new List<string>();
						    if (!string.IsNullOrEmpty(frame.ParentImageSop.PatientsAge)) components.Add(frame.ParentImageSop.PatientsAge);
						    if (!string.IsNullOrEmpty(frame.ParentImageSop.PatientsSex)) components.Add(frame.ParentImageSop.PatientsSex);
						    return string.Join(SR.SeparatorAgeSexBirthDate, components.ToArray());
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
					(
						"Dicom.PatientStudy.Composite.PatientsAgeSexBirthDate",
						resolver,
						delegate(Frame frame)
						{
						    var components = new List<string>();
						    if (!string.IsNullOrEmpty(frame.ParentImageSop.PatientsAge)) components.Add(frame.ParentImageSop.PatientsAge);
						    if (!string.IsNullOrEmpty(frame.ParentImageSop.PatientsSex)) components.Add(frame.ParentImageSop.PatientsSex);
						    if (!string.IsNullOrEmpty(frame.ParentImageSop.PatientsBirthDate)) components.Add(DicomDataFormatHelper.DateFormat(frame.ParentImageSop.PatientsBirthDate));
						    return string.Join(SR.SeparatorAgeSexBirthDate, components.ToArray());
						},
						DicomDataFormatHelper.RawStringFormat
					)
				);
		}
		public MRImageAnnotationItemProvider()
			: base("AnnotationItemProviders.Dicom.MRImage", new AnnotationResourceResolver(typeof (MRImageAnnotationItemProvider).Assembly))
		{
			_annotationItems = new List<IAnnotationItem>();

			AnnotationResourceResolver resolver = new AnnotationResourceResolver(this);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.MRImage.EchoTime",
						resolver,
						delegate(Frame frame)
							{
								double value;
								bool tagExists = frame[DicomTags.EffectiveEchoTime].TryGetFloat64(0, out value) || frame[DicomTags.EchoTime].TryGetFloat64(0, out value);
								if (tagExists)
									return String.Format(SR.FormatMilliseconds, value.ToString("F2"));

								return "";
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.MRImage.MagneticFieldStrength",
						resolver,
						delegate(Frame frame)
							{
								double value;
								bool tagExists = frame[DicomTags.MagneticFieldStrength].TryGetFloat64(0, out value);
								if (tagExists)
									return String.Format(SR.FormatTeslas, value.ToString("F1"));

								return "";
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.MRImage.AcquisitionMatrix",
						resolver,
						delegate(Frame frame)
							{
								// the acquisition matrix of an MR image refers to the dimensions of the raw data as acquired by the modality
								// which is encoded in frequency domain, so the two axes are phase and frequency
								// it seems that we simply want the width x height of the raw data here
								// which is basically figuring out whether phase is rows or cols, and formatting the numbers appropriately
								string phaseDirection = frame[DicomTags.InPlanePhaseEncodingDirection].ToString().ToUpperInvariant();

								var acqAttrib = frame[DicomTags.AcquisitionMatrix];
								if (!acqAttrib.IsEmpty && acqAttrib.Count >= 4)
								{
									// the order of the values in this attribute is: freq-rows \ freq-cols \ phase-rows \ phase-cols
									// the acquisition matrix tag is used by MR Image module, which uses the code string COL and ROW
									switch (phaseDirection)
									{
										case "COL":
											const int phaseColumns = 3;
											const int frequencyRows = 0;
											return String.Format(SR.Format2Dimensions, acqAttrib.GetUInt16(phaseColumns, 0), acqAttrib.GetUInt16(frequencyRows, 0));
										case "ROW":
										default:
											const int frequencyColumns = 1;
											const int phaseRows = 2;
											return String.Format(SR.Format2Dimensions, acqAttrib.GetUInt16(frequencyColumns, 0), acqAttrib.GetUInt16(phaseRows, 0));
									}
								}
								else
								{
									int phaseSteps, frequencySteps;
									if (frame[DicomTags.MrAcquisitionFrequencyEncodingSteps].TryGetInt32(0, out frequencySteps)
									    && frame[DicomTags.MrAcquisitionPhaseEncodingStepsInPlane].TryGetInt32(0, out phaseSteps))
									{
										// in the MR FOV/Geometry functional group, the code strings are COLUMN, ROW and OTHER
										switch (phaseDirection)
										{
											case "COLUMN":
												return string.Format(SR.Format2Dimensions, phaseSteps, frequencySteps);
											case "ROW":
												return string.Format(SR.Format2Dimensions, frequencySteps, phaseSteps);
										}
									}
								}

								return string.Empty;
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.MRImage.ReceiveCoilName",
						resolver,
						delegate(Frame frame)
							{
								string value;
								value = frame[DicomTags.ReceiveCoilName].GetString(0, null);
								return value;
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.MRImage.RepetitionTime",
						resolver,
						delegate(Frame frame)
							{
								double value;
								bool tagExists = frame[DicomTags.RepetitionTime].TryGetFloat64(0, out value);
								if (tagExists)
									return String.Format(SR.FormatMilliseconds, value.ToString("F2"));

								return "";
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.MRImage.EchoTrainLength",
						resolver,
						delegate(Frame frame)
							{
								int value;
								bool tagExists = frame[DicomTags.EchoTrainLength].TryGetInt32(0, out value);
								if (tagExists)
									return String.Format("{0}", value);

								return "";
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.MRImage.InversionTime",
						resolver,
						delegate(Frame frame)
							{
								double value;
								var tagExists = frame[DicomTags.InversionTime].TryGetFloat64(0, out value);
								if (tagExists) return string.Format(SR.FormatMilliseconds, value.ToString("F2"));

								DicomAttribute dicomAttribute;
								if (((IDicomAttributeProvider) frame).TryGetAttribute(DicomTags.InversionTimes, out dicomAttribute) && !dicomAttribute.IsEmpty && !dicomAttribute.IsNull)
								{
									var values = dicomAttribute.Values as double[];
									if (values != null) return string.Format(SR.FormatMilliseconds, DicomStringHelper.GetDicomStringArray(values, "F2"));
								}
								return string.Empty;
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.MRImage.TriggerTime",
						resolver,
						delegate(Frame frame)
							{
								double value;
								var tagExists = frame[DicomTags.TriggerTime].TryGetFloat64(0, out value);
								if (tagExists) return string.Format(SR.FormatMilliseconds, value.ToString("F2"));

								DicomAttribute dicomAttribute;
								if (((IDicomAttributeProvider) frame).TryGetAttribute(DicomTags.NominalCardiacTriggerDelayTime, out dicomAttribute) && !dicomAttribute.IsEmpty && !dicomAttribute.IsNull)
								{
									tagExists = dicomAttribute.TryGetFloat64(0, out value);
									if (tagExists) return string.Format(SR.FormatMilliseconds, value.ToString("F2"));
								}
								return string.Empty;
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.MRImage.NumberOfAverages",
						resolver,
						delegate(Frame frame)
							{
								double value;
								var tagExists = frame[DicomTags.NumberOfAverages].TryGetFloat64(0, out value);
								return tagExists ? string.Format("{0}", value) : string.Empty;
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.MRImage.PixelBandwidth",
						resolver,
						delegate(Frame frame)
							{
								double value;
								var tagExists = frame[DicomTags.PixelBandwidth].TryGetFloat64(0, out value);
								return tagExists ? string.Format(SR.FormatHertzPerPixel, value.ToString("F2")) : string.Empty;
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);

			_annotationItems.Add
				(
					new DicomAnnotationItem<string>
						(
						"Dicom.MRImage.FlipAngle",
						resolver,
						delegate(Frame frame)
							{
								double value;
								var tagExists = frame[DicomTags.FlipAngle].TryGetFloat64(0, out value);
								return tagExists ? string.Format(SR.FormatDegrees, value.ToString("F2")) : string.Empty;
							},
						DicomDataFormatHelper.RawStringFormat
						)
				);
		}