dicomformat.cs

ecg tool kit for medical image retrieval system

		{
			get {return null;}
			set {}
		}
		public string ReferringPhysician
		{
			get {return _DICOMData.GetString(Tags.ReferringPhysicianName);}
			set {if (value != null) _DICOMData.PutPN(Tags.ReferringPhysicianName, value);}
		}
		public string OverreadingPhysician
		{
			get {return _DICOMData.GetString(Tags.NameOfPhysicianReadingStudy);}
			set {if (value != null) _DICOMData.PutPN(Tags.NameOfPhysicianReadingStudy, value);}
		}
		public string TechnicianDescription
		{
			get {return _DICOMData.GetString(Tags.OperatorName);}
			set {if (value != null) _DICOMData.PutPN(Tags.OperatorName, value);}
		}
		public ushort SystolicBloodPressure
		{
			get {return 0;}
			set {}
		}
		public ushort DiastolicBloodPressure
		{
			get {return 0;}
			set {}
		}
		public Drug[] Drugs
		{
			get {return null;}
			set {}
		}
		public string[] ReferralIndication
		{
			get {return null;}
			set {}
		}
		public string RoomDescription
		{
			get {return null;}
			set {}
		}
		public byte StatCode
		{
			get {return 0xff;}
			set {}
		}
		#endregion

		#region IDiagnostic Members

		public int getDiagnosticStatements(out Statements stat)
		{
			stat = null;

			DcmElement element = _DICOMData.Get(Tags.AnnotationSeq);

			int annotationGroupNumber = -1;
			
			if (element != null)
			{
				ArrayList al = new ArrayList();

				int nr = element.vm();
				for (int i=0;i < nr;i++)
				{
					Dataset ds = element.GetItem(i);

					string line = ds.GetString(Tags.UnformattedTextValue);

					try
					{
						if (line != null)
						{
							if (annotationGroupNumber < 0)
								annotationGroupNumber = ds.GetInteger(Tags.AnnotationGroupNumber);

							if (annotationGroupNumber == ds.GetInteger(Tags.AnnotationGroupNumber))
								al.Add(line);
						}
					}
					catch
					{
					}
				}

				if (al.Count > 0)
				{
					stat = new Statements();

					if (Regex.IsMatch((string) al[al.Count-1], "(UN)?(CONFIRMED REPORT)", RegexOptions.None))
					{
						string temp = (string) al[al.Count-1];

						stat.confirmed = temp.StartsWith("CONF");

						al.RemoveAt(al.Count-1);
					}

					stat.time = _DICOMData.GetDate(stat.confirmed ? Tags.VerificationDateTime : Tags.ObservationDateTime);

					if ((OverreadingPhysician == null)
					||  (stat.time.Year <= 1000))
						stat.time = TimeAcquisition;

					stat.statement = new string[al.Count];

					for (int i=0;i < stat.statement.Length;i++)
						stat.statement[i] = (string) al[i];

					return 0;
				}
			}

			return 1;
		}

		public int setDiagnosticStatements(Statements stat)
		{
			if ((stat != null)
			&&  (stat.time.Year > 1000)
			&&  (stat.statement != null)
			&&  (stat.statement.Length > 0))
			{
				DcmElement element = _DICOMData.Get(Tags.AnnotationSeq);

				int annotationGroupNumber = 0;
			
				if (element == null)
				{
					element = _DICOMData.PutSQ(Tags.AnnotationSeq);
				}
				else
				{
					int nr = element.vm();
					for (int i=0;i < nr;i++)
					{
						Dataset ds = element.GetItem(i);

						try
						{
							int temp = ds.GetInteger(Tags.AnnotationGroupNumber);

							if (annotationGroupNumber <= temp)
								annotationGroupNumber = temp + 1;
						}
						catch
						{
						}
					}
				}

				foreach (string line in stat.statement)
				{
					Dataset ds = element.AddNewItem();

					ds.PutUS(Tags.RefWaveformChannels, s_MeasurementRWC);
					ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
					ds.PutST(Tags.UnformattedTextValue, line);
				}

				if (OverreadingPhysician != null)
				{
					_DICOMData.PutDT(stat.confirmed ? Tags.VerificationDateTime : Tags.ObservationDateTime, stat.time);
				}

				if (stat.confirmed)
				{
					Dataset ds = element.AddNewItem();

					ds.PutUS(Tags.RefWaveformChannels, s_MeasurementRWC);
					ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
					ds.PutST(Tags.UnformattedTextValue, "CONFIRMED REPORT");
				}
				else
				{
					Dataset ds = element.AddNewItem();

					ds.PutUS(Tags.RefWaveformChannels, s_MeasurementRWC);
					ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
					ds.PutST(Tags.UnformattedTextValue, "UNCONFIRMED REPORT");
				}

				return 0;
			}

			return 1;
		}

		#endregion

		#region IGlobalMeasurement Members

		private static int[] s_MeasurementRWC = {1, 0};

		private static string[,] s_AvgRRPPItems = {{"5.10.2.1-3", "5.10.2.1-5", "5.10.2.5-5"}, {"RR Interval", "PP Interval", "QTc Interval"}};
		private static string[,] s_AvgRRPPUnits = {{"ms", "ms", "ms"}, {"milliseconds", "milliseconds", "milliseconds"}};

		private static string[,] s_MeasurementItems = {{"5.10.3-1", "5.10.3-2", "5.10.3-3", "5.10.3-4", "5.10.3-5", "5.10.3-11", "5.10.3-13", "5.10.3-15"}, {"P onset", "P offset", "QRS onset", "QRS offset", "T offset", "P Axis", "QRS Axis", "T Axis"}};
		private static string[,] s_MeasurementUnits = {{"ms", "ms", "ms", "ms", "ms", "deg", "deg", "deg"}, {"milliseconds", "milliseconds", "milliseconds", "milliseconds", "milliseconds", "degrees", "degrees", "degrees"}};
		private static string[,] s_MeasurementUnitsPoints = {{"POINT", "POINT", "POINT", "POINT", "POINT", "deg", "deg", "deg"}, {null, null, null, null, null, "degrees", "degrees", "degrees"}};

		public int getGlobalMeasurements(out GlobalMeasurements mes)
		{
			mes = null;

			string[,] resultAvgRR_PP = GetValues(_DICOMData.Get(Tags.AnnotationSeq), s_AvgRRPPItems, s_AvgRRPPUnits, s_MeasurementRWC);
			string[,] resultMeasurments = GetValues(_DICOMData.Get(Tags.AnnotationSeq), s_MeasurementItems, s_MeasurementUnits, s_MeasurementRWC, true);

			float factor = 1.0f;

			if (resultAvgRR_PP != null)
			{
				string[,] temp1 = GetValues(_DICOMData.Get(Tags.AnnotationSeq), s_MeasurementItems, s_MeasurementUnitsPoints, s_MeasurementRWC, true);

				if ((temp1 != null)
				&&	((resultMeasurments == null)
				||	 (resultMeasurments.Length < temp1.Length)
				||	 (calcNrOfValues(resultMeasurments) < calcNrOfValues(temp1))))
				{
					DcmElement temp2 = _DICOMData.Get(Tags.WaveformSeq);

					if ((temp2 != null)
					&&	(temp2.vm() >= 1))
					{
						try
						{
							factor = 1000.0f / int.Parse(temp2.GetItem(0).GetString(Tags.SamplingFrequency));
						}
						catch {}
					}

					resultMeasurments = temp1;
				}
			}

			if ((resultAvgRR_PP != null)
			&&	(resultMeasurments != null))
			{
				try
				{
					mes = new GlobalMeasurements();

					if (resultAvgRR_PP.GetLength(0) >= 1)
					{
						if (resultAvgRR_PP[0, 0] != null)
							mes.AvgRR = ushort.Parse(resultAvgRR_PP[0, 0], System.Globalization.CultureInfo.InvariantCulture.NumberFormat);

						if (resultAvgRR_PP[0, 1] != null)
							mes.AvgPP = ushort.Parse(resultAvgRR_PP[0, 1], System.Globalization.CultureInfo.InvariantCulture.NumberFormat);

						if (resultAvgRR_PP[0, 2] != null)
							mes.QTc = ushort.Parse(resultAvgRR_PP[0, 2], System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
					}

					int end1 = resultMeasurments.GetLength(0),
						end2 = resultMeasurments.GetLength(1) - 1;
					System.Reflection.FieldInfo[] fi = typeof(GlobalMeasurement).GetFields(System.Reflection.BindingFlags.Public | BindingFlags.Instance);

					if ((end1 > 0)
					&&	(end2 == fi.Length))
					{
						mes.measurment = new GlobalMeasurement[end1];

						for (int i=0;i < end1;i++)
						{
							mes.measurment[i] = new GlobalMeasurement();
							
							for (int j=0;j < end2;j++)
							{
								if (resultMeasurments[i,j] != null)
								{
									int temp = int.Parse(resultMeasurments[i, j]);

									if (fi[j].FieldType == typeof(ushort))
									{
										if ((temp >= ushort.MinValue)
										&&	(temp <= ushort.MaxValue))
											fi[j].SetValue(mes.measurment[i], (ushort)(temp * factor));
									}
									else if (fi[j].FieldType == typeof(short))
									{
										if ((temp >= short.MinValue)
										&&	(temp <= short.MaxValue))
											fi[j].SetValue(mes.measurment[i], (short)temp);
									}
									else
										throw new Exception("Error by developer!");
								}
							}
						}
					}

					return 0;
				}
				catch
				{
					mes = null;
				}
			}

			return 1;
		}

		public int setGlobalMeasurements(GlobalMeasurements mes)
		{
			if ((mes != null)
			&&	(mes.measurment != null))
			{
				DcmElement element = _DICOMData.Get(Tags.AnnotationSeq);

				int annotationGroupNumber = 0;
			
				if (element == null)
				{
					element = _DICOMData.PutSQ(Tags.AnnotationSeq);
				}
				else
				{
					int nr = element.vm();
					for (int i=0;i < nr;i++)
					{
						Dataset ds = element.GetItem(i);

						try
						{
							int temp = ds.GetInteger(Tags.AnnotationGroupNumber);

							if (annotationGroupNumber <= temp)
								annotationGroupNumber = temp + 1;
						}
						catch
						{
						}
					}
				}

				if (mes.AvgRR != GlobalMeasurement.NoValue)
				{
					Dataset ds = element.AddNewItem();

					MakeCodeSequence(ds, Tags.MeasurementUnitsCodeSeq, s_AvgRRPPUnits[0, 0], "UCUM", "1.4", s_AvgRRPPUnits[1, 0]);
					MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, s_AvgRRPPItems[0, 0], "SCPECG", "1.3", s_AvgRRPPItems[1, 0]);

					ds.PutUS(Tags.RefWaveformChannels, s_MeasurementRWC);
					ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
					ds.PutDS(Tags.NumericValue, mes.AvgRR);
				}

				if (mes.AvgPP != GlobalMeasurement.NoValue)
				{
					Dataset ds = element.AddNewItem();

					MakeCodeSequence(ds, Tags.MeasurementUnitsCodeSeq, s_AvgRRPPUnits[0, 1], "UCUM", "1.4", s_AvgRRPPUnits[1, 1]);
					MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, s_AvgRRPPItems[0, 1], "SCPECG", "1.3", s_AvgRRPPItems[1, 1]);

					ds.PutUS(Tags.RefWaveformChannels, s_MeasurementRWC);
					ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
					ds.PutDS(Tags.NumericValue, mes.AvgPP);
				}

				if (mes.PRint != GlobalMeasurement.NoValue)
				{
					Dataset ds = element.AddNewItem();

					MakeCodeSequence(ds, Tags.MeasurementUnitsCodeSeq, "ms", "UCUM", "1.4", "milliseconds");
					MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, "5.13.5-7", "SCPECG", "1.3", "PR Interval");
					
					ds.PutUS(Tags.RefWaveformChannels, s_MeasurementRWC);
					ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
					ds.PutDS(Tags.NumericValue, mes.PRint);
				}

				if (mes.QRSdur != GlobalMeasurement.NoValue)
				{
					Dataset ds = element.AddNewItem();

					MakeCodeSequence(ds, Tags.MeasurementUnitsCodeSeq, "ms", "UCUM", "1.4", "milliseconds");
					MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, "5.13.5-9", "SCPECG", "1.3", "QRS Duration");
					
					ds.PutUS(Tags.RefWaveformChannels, s_MeasurementRWC);
					ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
					ds.PutDS(Tags.NumericValue, mes.QRSdur);
				}

				if (mes.QTdur != GlobalMeasurement.NoValue)
				{
					Dataset ds = element.AddNewItem();

					MakeCodeSequence(ds, Tags.MeasurementUnitsCodeSeq, "ms", "UCUM", "1.4", "milliseconds");
					MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, "5.13.5-11", "SCPECG", "1.3", "QT Interval");
					
					ds.PutUS(Tags.RefWaveformChannels, s_MeasurementRWC);
					ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
					ds.PutDS(Tags.NumericValue, mes.QTdur);
				}

				if (mes.QTc != GlobalMeasurement.NoValue)
				{
					Dataset ds = element.AddNewItem();

					MakeCodeSequence(ds, Tags.MeasurementUnitsCodeSeq, "ms", "UCUM", "1.4", "milliseconds");
					MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, "5.10.2.5-5", "SCPECG", "1.3", "QTc Interval");
					
					ds.PutUS(Tags.RefWaveformChannels, s_MeasurementRWC);
					ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
					ds.PutDS(Tags.NumericValue, mes.QTc);
				}

				if (mes.measurment.Length > 0)
				{
					int MortaraCompat = 0;

					try
					{
						MortaraCompat = int.Parse(_DICOMData.Get(Tags.WaveformSeq).GetItem(0).GetString(Tags.SamplingFrequency));
					}
					catch {}
				
					if (MortaraCompat != 0)
					{
						if (mes.measurment[0].Paxis != GlobalMeasurement.NoAxisValue)
						{
							Dataset ds = element.AddNewItem();

							MakeCodeSequence(ds, Tags.MeasurementUnitsCodeSeq, "ms", "UCUM", "1.4", "milliseconds");
							MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, "5.10.3-11", "SCPECG", "1.3", "P Axis");

							ds.PutUS(Tags.RefWaveformChannels, s_MeasurementRWC);
							ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
							ds.PutDS(Tags.NumericValue, mes.measurment[0].Paxis);
						}

						if (mes.measurment[0].QRSaxis != GlobalMeasurement.NoAxisValue)
						{
							Dataset ds = element.AddNewItem();

							MakeCodeSequence(ds, Tags.MeasurementUnitsCodeSeq, "ms", "UCUM", "1.4", "milliseconds");
							MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, "5.10.3-13", "SCPECG", "1.3", "QRS Axis");

							ds.PutUS(Tags.RefWaveformChannels, s_MeasurementRWC);
							ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
							ds.PutDS(Tags.NumericValue, mes.measurment[0].QRSaxis);
						}

						if (mes.measurment[0].Taxis != GlobalMeasurement.NoAxisValue)
						{
							Dataset ds = element.AddNewItem();

							MakeCodeSequence(ds, Tags.MeasurementUnitsCodeSeq, "ms", "UCUM", "1.4", "milliseconds");
							MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, "5.10.3-15", "SCPECG", "1.3", "T Axis");

							ds.PutUS(Tags.RefWaveformChannels, s_MeasurementRWC);
							ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
							ds.PutDS(Tags.NumericValue, mes.measurment[0].Taxis);
						}

						annotationGroupNumber++;

						int[] tempRWC = s_MeasurementRWC;

						if (mes.measurment[0].Ponset != GlobalMeasurement.NoValue)
						{
							Dataset ds = element.AddNewItem();

							MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, s_MeasurementItems[0, 0], "SCPECG", "1.3", s_MeasurementItems[1, 0]);

							ds.PutUS(Tags.RefWaveformChannels, tempRWC);
							ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);

							ds.PutCS(Tags.TemporalRangeType, s_MeasurementUnitsPoints[0, 0]);
							ds.PutUL(Tags.RefSamplePositions, (mes.measurment[0].Ponset * MortaraCompat) / 1000);
						}

						if (mes.measurment[0].Poffset != GlobalMeasurement.NoValue)
						{
							Dataset ds = element.AddNewItem();

							MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, s_MeasurementItems[0, 1], "SCPECG", "1.3", s_MeasurementItems[1, 1]);

							ds.PutUS(Tags.RefWaveformChannels, tempRWC);
							ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
							
							ds.PutCS(Tags.TemporalRangeType, s_MeasurementUnitsPoints[0, 1]);
							ds.PutUL(Tags.RefSamplePositions, (mes.measurment[0].Poffset * MortaraCompat) / 1000);
						}

						if (mes.measurment[0].QRSonset != GlobalMeasurement.NoValue)
						{
							Dataset ds = element.AddNewItem();

							MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, s_MeasurementItems[0, 2], "SCPECG", "1.3", s_MeasurementItems[1, 2]);

							ds.PutUS(Tags.RefWaveformChannels, tempRWC);
							ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
							
							ds.PutCS(Tags.TemporalRangeType, s_MeasurementUnitsPoints[0, 2]);
							ds.PutUL(Tags.RefSamplePositions, (mes.measurment[0].QRSonset * MortaraCompat) / 1000);
						}

						if (_FiducialPoint != 0)
						{
							ushort temp = (ushort) ((mes.measurment[0].QRSonset + mes.measurment[0].QRSoffset) >> 1);

							Dataset ds = element.AddNewItem();

							MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, "5.7.1-3", "SCPECG", "1.3", "Fiducial Point");

							ds.PutUS(Tags.RefWaveformChannels, tempRWC);
							ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
							
							ds.PutCS(Tags.TemporalRangeType, "POINT");
							ds.PutUL(Tags.RefSamplePositions, _FiducialPoint);
						}

						if (mes.measurment[0].QRSoffset != GlobalMeasurement.NoValue)
						{
							Dataset ds = element.AddNewItem();

							MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, s_MeasurementItems[0, 3], "SCPECG", "1.3", s_MeasurementItems[1, 3]);

							ds.PutUS(Tags.RefWaveformChannels, tempRWC);
							ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
							
							ds.PutCS(Tags.TemporalRangeType, s_MeasurementUnitsPoints[0, 3]);
							ds.PutUL(Tags.RefSamplePositions, (mes.measurment[0].QRSoffset * MortaraCompat) / 1000);
						}

						if (mes.measurment[0].Toffset != GlobalMeasurement.NoValue)
						{
							Dataset ds = element.AddNewItem();

							MakeCodeSequence(ds, Tags.ConceptNameCodeSeq, s_MeasurementItems[0, 4], "SCPECG", "1.3", s_MeasurementItems[1, 4]);

							ds.PutUS(Tags.RefWaveformChannels, tempRWC);
							ds.PutUS(Tags.AnnotationGroupNumber, annotationGroupNumber);
							
							ds.PutCS(Tags.TemporalRangeType, s_MeasurementUnitsPoints[0, 4]);
							ds.PutUL(Tags.RefSamplePositions, (mes.measurment[0].Toffset * MortaraCompat) / 1000);
						}

						annotationGroupNumber = 100;
					}

					System.Reflection.FieldInfo[] fi = mes.measurment[0].GetType().GetFields(System.Reflection.BindingFlags.Public | BindingFlags.Instance);

                    int end = s_MeasurementItems.GetLength(1);

					if (end != fi.Length)
						return 2;

					string[,] tempMeasurementUnits = (MortaraCompat == 0) ? s_MeasurementUnits : s_MeasurementUnitsPoints;

					for (int i=(MortaraCompat == 0) ? 0 : 1;i < mes.measurment.Length;i++)