dicomformat.cs

ecg tool kit for medical image retrieval system

					{
						int[] tempRWC = (i == 0) ? new int[]{2, 0} : s_MeasurementRWC;

						for (int j=0;j < end;j++)
						{
							Dataset ds = element.AddNewItem();

                            int val = ECGConversion.ECGGlobalMeasurements.GlobalMeasurement.NoValue;
                            object tempVal = fi[j].GetValue(mes.measurment[i]);

							if (tempVal.GetType() == typeof(ushort))
								val = (ushort)tempVal;
							else if (tempVal.GetType() == typeof(short))
							{
								if (MortaraCompat != 0)
									continue;

								val = (short)tempVal;
							}
							else if (tempVal.GetType() == typeof(int))
								val = (int)tempVal;

							if (val != GlobalMeasurement.NoValue)
							{
								if (tempMeasurementUnits[1, j] != null)
								{
									MakeCodeSequence(ds, Tags.MeasurementUnitsCodeSeq, tempMeasurementUnits[0, j], "UCUM", "1.4", tempMeasurementUnits[1, j]);
									ds.PutDS(Tags.NumericValue, val);
								}
								else
								{
									ds.PutCS(Tags.TemporalRangeType, tempMeasurementUnits[0, j]);
									ds.PutUL(Tags.RefSamplePositions, (MortaraCompat == 0) || (MortaraCompat == 1000) ? val : (val * MortaraCompat) / 1000);
								}

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

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

						annotationGroupNumber++;
					}
				}

				return 0;
			}

			return 1;
		}

		#endregion

		public static int calcNrOfValues(string[,] vals)
		{
			int nr = 0;

			if (vals != null)
			{
				int end1 = vals.GetLength(0),
					end2 = vals.GetLength(1);

				for (int i=0;i < end1;i++)
					for (int j=0;j < end2;j++)
						if (vals[i,j] != null)
							nr++;
			}

			return nr;
		}

		public static string[,] GetValues(DcmElement element, string[,] items, string[,] units, int[] rwc)
		{
			return GetValues(element, items, units, rwc, false);
		}

		public static string[,] GetValues(DcmElement element, string[,] items, string[,] units, int[] rwc, bool special)
		{
			if ((element != null)
			&&	(items != null)
			&&	(units != null)
			&&	(items.Length == units.Length))
			{
				int end = element.vm();

				SortedList sl = new SortedList();

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

					string itemName;

					if (IsCodeSequence(ds, Tags.ConceptNameCodeSeq, out itemName, "SCPECG", "1.3"))
					{
						int nr = 0;

						for (;nr < items.GetLength(1);nr++)
							if (string.Compare(items[0, nr], itemName) == 0)
								break;

						if (nr == items.GetLength(1))
							continue;

						string val = null;
						int groupNr = ds.GetInteger(Tags.AnnotationGroupNumber);

						if (units[1, nr] == null)
						{
							if (units[0, nr] == ds.GetString(Tags.TemporalRangeType))
								val = ds.GetString(Tags.RefSamplePositions);
						}
						else if (IsCodeSequence(ds, Tags.MeasurementUnitsCodeSeq, out val, "UCUM", "1.4"))
						{
							val = ds.GetString(Tags.NumericValue);
						}

						int[] tempRWC = ds.GetInts(Tags.RefWaveformChannels);

						if ((val != null)
						&&	(groupNr >= 0)
						&&	(tempRWC.Length == rwc.Length))
						{
							for (int k=0;k < rwc.Length;k++)
								if (tempRWC[k] != rwc[k])
									continue;

							string[] temp = null;

							if (sl.Contains(groupNr))
								temp = (string[]) sl[groupNr];
							else
							{
								temp = new string[items.GetLength(1)];

								sl.Add(groupNr, temp);
							}

							temp[nr] = val;
						}
					}
				}

				if (sl.Count > 0)
				{
					if (special
					&&	(sl.Count > 1)
					&&	(items.GetLength(1) < 64))
					{
						int temp1 = items.GetLength(1);
						ulong a = 0, b = 0; 

						string[] temp2 = (string[]) sl.GetByIndex(0);
						for (int i=0;i < temp1;i++)
							if (temp2[i] != null)
								a |= (1UL << i);

						string[] temp3 = (string[]) sl.GetByIndex(1);
						for (int i=0;i < temp1;i++)
							if (temp3[i] != null)
								b |= (1UL << i);

						if ((a ^ b) == (a + b))
						{
							for (int i=0;i < temp1;i++)
								if (temp2[i] != null)
									temp3[i] = temp2[i];

							sl.RemoveAt(0);
						}
					}

					string[,] ret = new string[sl.Count, items.GetLength(1)+1];

					for (int i=0;i < sl.Count;i++)
					{
						string[] temp = (string[]) sl.GetByIndex(i);
						int j=0;

						for (;j < temp.Length;j++)
							ret[i, j] = temp[j];

						ret[i, j] = sl.GetKey(i).ToString();
					}

					return ret;
				}
			}

			return null;
		}

		public float GetFilter(Dataset ds, uint tag)
		{
			string str = null;

			DcmElement ele = ds.Get(Tags.ChannelDefInitionSeq);

			for (int i=0;i < ele.vm();i++)
			{
				string temp = ele.GetItem(i).GetString(tag);

				if (str == null)
					str = temp;

				if (str == null)
					return float.NaN;;

				if (string.Compare(str, temp, true) != 0)
					return float.NaN;
			}

			return float.Parse(str, System.Globalization.CultureInfo.InvariantCulture);
		}

		public int GetWaveform(Signals sigs, DcmElement chDef, int[] data, int nrSamples, bool median)
		{
			if ((sigs == null)
			||	(chDef == null)
			||	(data == null)
			||	(sigs.NrLeads != chDef.vm()))
				return 1;

			if (nrSamples <= 0)
				return 0;

			byte nrLeads = sigs.NrLeads;

			if ((nrLeads * nrSamples) > data.Length)
				return 2;

			try
			{
				for (int i=0;i < nrLeads;i++)
				{
					Dataset ds = chDef.GetItem(i);

					double val, baseline, skew;
					LeadType type;

					GetChannelInfo(ds, out type, out val, out baseline, out skew);

					if ((val == 0.0)
					&&	(skew != 0.0))
						return 4;

					if (i == 0)
					{
						if (median)
							sigs.MedianAVM = val;
						else
							sigs.RhythmAVM = val;
					}

					if (sigs[i] == null)
					{
						sigs[i] = new Signal();
						sigs[i].Type = type;
					}

					if (sigs[i].Type != type)
						return 5;

					short[] values = new short[nrSamples];
					int pos = i;

					for (int j=0;j < nrSamples;j++,pos+=nrLeads)
						values[j] = (short) data[pos];

					ECGTool.ChangeMultiplier(values, val, (median ? sigs.MedianAVM : sigs.RhythmAVM));

					if (median)
					{
						sigs[i].Median = values;
					}
					else
					{
						sigs[i].Rhythm = values;
						sigs[i].RhythmStart = 0;
						sigs[i].RhythmEnd = nrSamples-1;
					}
				}
			}
			catch
			{
				return 3;
			}

			return 0;
		}

		public int SetWaveform(Dataset ds, Signals sigs, bool median)
		{
			try
			{
				byte nrLeads = sigs.NrLeads;
				int start, end, ret = 0;

				if (median)
				{
					start = 0;
					end = (sigs.MedianLength * sigs.MedianSamplesPerSecond) / 1000;
				}
				else
				{
					sigs.CalculateStartAndEnd(out start, out end);
				}

				int len = end - start;

				if (_MortaraCompat)
				{
					len = (median ? 1200 : 10000); 

					len = ((sigs.RhythmSamplesPerSecond * len) / 1000);
				}
				
				ds.PutDS(Tags.MultiplexGroupTimeOffset, 0);
				ds.PutDS(Tags.TriggerTimeOffset, 0);

				ds.PutCS(Tags.WaveformOriginality, (median ? "DERIVED" : "ORIGINAL"));
				ds.PutUS(Tags.NumberOfWaveformChannels, nrLeads);
				ds.PutUL(Tags.NumberOfWaveformSamples, len);
				ds.PutDS(Tags.SamplingFrequency, median ? sigs.MedianSamplesPerSecond : sigs.RhythmSamplesPerSecond);
				ds.PutSH(Tags.MultiplexGroupLabel, (median ? "MEDIAN BEAT" : "RHYTHM"));

				ret = SetChannelInfo(ds.PutSQ(Tags.ChannelDefInitionSeq), sigs, median);

				if (ret != 0)
					return ret > 0 ? 1 + ret : ret;

				ds.PutUS(Tags.WaveformBitsAllocated, 16);
				ds.PutCS(Tags.WaveformSampleInterpretation, "SS");

				if (median)
					ds.PutUL(Tags.TriggerSamplePosition, sigs.MedianFiducialPoint);

				if (!median)
					ds.PutOW(Tags.WaveformPaddingValue, new short[]{(_MortaraCompat ? (short) 0 : short.MinValue)});

				short[][] temp = new short[nrLeads][];

				if (median)
				{
					for (int n=0;n < nrLeads;n++)
					{
						if (sigs[n].Median.Length == len)
						{
							temp[n] = sigs[n].Median;
						}
						else
						{
							Signal tempSig = sigs[n];

							temp[n] = new short[len];

							for (int i=0;i < len;i++)
							{
								temp[n][i] = (i < tempSig.Median.Length)
									?	tempSig.Median[i]
									:	short.MinValue;
							}
						}
					}
				}
				else
				{
					for (int n=0;n < nrLeads;n++)
					{
						if ((sigs[n].RhythmStart == start)
							&&	(sigs[n].RhythmEnd == end)
							&&	(sigs[n].Rhythm.Length == len))
						{
							temp[n] = sigs[n].Rhythm;
						}
						else
						{
							Signal tempSig = sigs[n];

							temp[n] = new short[len];

							for (int i=0,j=start;(j < tempSig.RhythmEnd) && (j < len);i++,j++)
							{
								temp[n][i] = (j >= tempSig.RhythmStart)
									?	tempSig.Rhythm[j - tempSig.RhythmStart]
									:	short.MinValue;
							}
						}
					}
				}

				ds.PutOW(Tags.WaveformData, temp);
			}
			catch
			{
				return 1;
			}

			return 0;
		}

		public void GetChannelInfo(Dataset ds, out LeadType type, out double val, out double baseline, out double skew)
		{
			val = 1.0;
			type = LeadType.Unknown;
			baseline = 0.0;
			skew = 0.0;

			if (string.Compare(ds.GetString(Tags.ChannelSensitivityCorrectionFactor), "1") != 0)
				return;

			try
			{
				DcmElement el = ds.Get(Tags.ChannelSensitivityUnitsSeq);

				switch (el.GetItem(0).GetString(Tags.CodeValue))
				{
					case "MV":
						val = 1000000000000.0;
						break;
					case "kV":
						val = 1000000000.0;
						break;
					case "V":
						val = 1000000.0;
						break;
					case "dV":
						val = 100000.0;
						break;
					case "cV":
						val = 10000.0;
						break;
					case "mV":
						val = 1000.0;
						break;
					case "uV":
						val = 1.0;
						break;
				}

				val *= double.Parse(ds.GetString(Tags.ChannelSensitivity), System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
			}
			catch
			{
				val = 0.0f;
			}

			try
			{
				baseline = double.Parse(ds.GetString(Tags.ChannelBaseline), System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
			} catch {}

			try
			{
				skew = double.Parse(ds.GetString(Tags.ChannelSampleSkew), System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
			} catch {}

			try
			{
				Dataset ds2 = ds.Get(Tags.ChannelSourceSeq).GetItem(0);

				switch (ds2.GetString(Tags.CodingSchemeDesignator))
				{
					case "SCPECG":
					{
						string[] temp = ds2.GetString(Tags.CodeValue).Split('-');

						type = (LeadType) int.Parse(temp[temp.Length-1], System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
					}
						break;
					case "MDC":
					{
						type = (LeadType) Enum.Parse(typeof(LeadTypeVitalRefId), ds2.GetString(Tags.CodeValue));
					}
						break;
				}
			} catch {}
		}

		public int SetChannelInfo(DcmElement element, Signals sigs, bool median)
		{
			try
			{
				byte nrLeads = sigs.NrLeads;

				for (int i=0; i < nrLeads;i++)
				{
					Dataset ds = element.AddNewItem();

					MakeCodeSequence(ds, Tags.ChannelSourceSeq, "5.6.3-9-" + ((int)sigs[i].Type).ToString(), "SCPECG", "1.3", "Lead " + sigs[i].Type.ToString());

					ds.PutDS(Tags.ChannelSensitivity, (float) (median ? sigs.MedianAVM : sigs.RhythmAVM));

					MakeCodeSequence(ds, Tags.ChannelSensitivityUnitsSeq, "uV", "UCUM", "1.4", "microvolt");

					ds.PutDS(Tags.ChannelSensitivityCorrectionFactor, 1);
					ds.PutDS(Tags.ChannelBaseline, 0);
					ds.PutDS(Tags.ChannelSampleSkew, 0);
					ds.PutUS(Tags.WaveformBitsStored, 16);

					if (_LowpassFilter != 0)
						ds.PutDS(Tags.FilterHighFrequency, _LowpassFilter);

					if (_HighpassFilter != 0)
						ds.PutDS(Tags.FilterLowFrequency, (_HighpassFilter / 100.0f));

					if ((_FilterMap != 0)
					&&	((_FilterMap & 0x3) != 0x3)
					&&	((_FilterMap & 0x3) != 0x0))
						ds.PutDS(Tags.NotchFilterFrequency, ((_FilterMap & 0x1) == 0x1) ? 60.0f : 50.0f);
				}
			}
			catch
			{
				return 1;
			}

			return 0;
		}

		public static bool IsCodeSequence(Dataset ds, uint tag, out string codeValue, string codingSchemeDesignator, string codingSchemeVersion)
		{
			codeValue = null;

			DcmElement el = ds.Get(tag);

			if ((el != null)
			&&	(el.vm() == 1))
			{
				Dataset ds2 = el.GetItem(0);

				if ((ds2 != null)
				&&	(ds2.GetString(Tags.CodingSchemeDesignator) == codingSchemeDesignator)
				&&	((codingSchemeVersion == null)
				||	 (ds2.GetString(Tags.CodingSchemeVersion) == codingSchemeVersion)))
					codeValue = ds2.GetString(Tags.CodeValue);
			}

			return codeValue != null;
		}

		public static void MakeCodeSequence(Dataset ds, uint tag, string codeValue, string codingSchemeDesignator, string codingSchemeVersion, string codeMeaning)
		{
			DcmElement el =	ds.PutSQ(tag);
			ds = el.AddNewItem();

			ds.PutSH(Tags.CodeValue, codeValue);
			ds.PutSH(Tags.CodingSchemeDesignator, codingSchemeDesignator);
			ds.PutSH(Tags.CodingSchemeVersion, codingSchemeVersion);
			ds.PutLO(Tags.CodeMeaning, codeMeaning);
		}
	}
}