ecgconverter.cs

ecg tool kit for medical image retrieval system

		/// Function to get the extra offset.
		/// </summary>
		/// <param name="i">position in list</param>
		/// <returns>extra offset</returns>
		public int getExtraOffset(int i)
		{
			if ((i < 0)
			||	(i >= _SupportedFormats.Count))
				return 0;

			return ((ECGPlugin)_SupportedFormats.GetByIndex(i)).ExtraOffset;
		}
		
		/// <summary>
		/// Function that will add plugin to supported list.
		/// </summary>
		/// <param name="plugin">the plugin</param>
		public void AddPlugin(ECGPlugin plugin)
		{
			if ((plugin != null)
			&&	(plugin.Name != null))
			{
				string temp = plugin.Name.ToUpper();

				int index = _SupportedFormats.IndexOfKey(temp);

				if (index >= 0)
					_SupportedFormats.SetByIndex(index, plugin);
				else
					_SupportedFormats.Add(temp, plugin);
			}	
		}

		/// <summary>
		/// Function that will add plugin to supported list.
		/// </summary>
		/// <param name="plugin">the plugin</param>
		public void AddPlugin(ECGManagementSystem.IECGManagementSystem manSys)
		{
			if ((manSys != null)
			&&	(manSys.Name != null))
			{
				string temp = manSys.Name.ToUpper();

				int index = _SupportedECGMS.IndexOfKey(temp);

				if (index >= 0)
					_SupportedECGMS.SetByIndex(index, manSys);
				else
					_SupportedECGMS.Add(temp, manSys);
			}	
		}

        /// <summary>
        /// Function to add all plugins in a directory.
        /// </summary>
        /// <param name="dir">directory to detect plugins from</param>
        /// <returns>returns 0 if successful</returns>
        public static int AddPlugins(string dir)
        {
            return AddPlugins(Instance, dir);
        }

        /// <summary>
        /// Function to add all plugins in a directory.
        /// </summary>
        /// <param name="converter">instance of the converter singleton</param>
        /// <param name="dir">directory to detect plugins from</param>
        /// <returns></returns>
        public static int AddPlugins(ECGConverter converter, string dir)
        {
            if (converter == null)
                return 1;

            try
            {
                if ((dir == null)
			    ||	(dir.Length == 0))
				    return 2;

    			string[] asPlugin = Directory.GetFiles(dir, "*.dll");

                String currentDll = System.IO.Path.GetFileName(Assembly.GetExecutingAssembly().Location);

    			foreach (string sPlugin in asPlugin)
	    		{
					if (String.Compare(System.IO.Path.GetFileName(sPlugin), currentDll, true) != 0)
					{
						AddPlugin(converter, sPlugin);
					}
			    }
            }
            catch (Exception)
            {
                return 3;
            }

            return 0;
        }

		/// <summary>
		/// Function that will add plugins from a certain dll to the supported list.
		/// </summary>
		/// <param name="dllfile">path to dll</param>
		/// <returns>returns 0 if successful</returns>
		public static int AddPlugin(string dllfile)
		{
			return AddPlugin(Instance, dllfile);
		}

		/// <summary>
		/// Function that will add plugins from a certain dll to the supported list.
		/// </summary>
		/// <param name="converter">the object to add the plugin to</param>
		/// <param name="dllfile">path to dll</param>
		/// <returns>returns 0 if successful</returns>
		private static int AddPlugin(ECGConverter converter, string dllfile)
		{
			if (converter == null)
				return 1;

			try
			{
				Assembly assembly = Assembly.LoadFrom(dllfile);
				Type type = assembly.GetType("ECGConversion.ECGLoad");
				MethodInfo methodInfo = type.GetMethod("LoadPlugin");

				if (methodInfo != null)
				{
					foreach (ECGPlugin plugin in (Array) methodInfo.Invoke(null, null))
						if (plugin != null)
							converter.AddPlugin(plugin);
				}

				methodInfo = type.GetMethod("LoadECGMS");

				if (methodInfo != null)
				{
					foreach (ECGManagementSystem.IECGManagementSystem ecgms in (Array) methodInfo.Invoke(null, null))
						if (ecgms != null)
							converter.AddPlugin(ecgms);
				}
			}
			catch (Exception)
			{
				return 2;
			}

			return 0;
		}

		/// <summary>
		/// Function to write an ECG to Txt file that can be read with Excel.
		/// </summary>
		/// <param name="src">an ECG file to convert</param>
		/// <param name="output">stream to write Txt in.</param>
		/// <param name="hSeperator">Horizontal seperator to use</param>
		/// <returns>0 on success</returns>
		public static int ToExcelTxt(IECGFormat src, TextWriter output, char hSeperator)
		{
			if ((src != null)
			&&	(output != null))
			{
				ISignal sigread = src.Signals;
				if (sigread != null)
				{
					Signals data;
					sigread.getSignals(out data);

					if ((data != null)
					&&	(data.NrLeads != 0))
					{
						// Determine minimum start and maximum end.
						int minstart = int.MaxValue;
						int maxend = int.MinValue;

						data.CalculateStartAndEnd(out minstart, out maxend);

						output.Write("samplenr");
						for (int lead=0;lead < data.NrLeads;lead++)
						{
							if (data[lead] != null)
							{
								output.Write("{0}{1}", hSeperator, data[lead].Type);
							}
							else
							{
								output.Write("{0}?", hSeperator);
							}
						}
						output.WriteLine();

						for (int sample=minstart;sample < maxend;sample++)
						{
							output.Write("{0}", sample);
							for (int lead=0;lead < data.NrLeads;lead++)
							{
								if ((data[lead] != null)
								&&	(data[lead].Rhythm != null)
								&&	(data[lead].Rhythm.Length >= (data[lead].RhythmEnd - data[lead].RhythmEnd))
								&&	(sample >= data[lead].RhythmStart)
								&&	(sample < data[lead].RhythmEnd))
								{
									output.Write("{0}{1}", hSeperator, (data[lead].Rhythm[sample - data[lead].RhythmStart] * data.RhythmAVM).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat));
								}
								else
								{
									output.Write("{0}0", hSeperator);
								}
							}
							output.WriteLine();
						}

						return 0;
					}
					return 4;
				}
				return 2;
			}
			return 1;
		}
		/// <summary>
		/// Function to write an ECG to Txt file that can be read with MatLab.
		/// </summary>   
		/// <param name="src">an ECG file to convert</param>
		/// <param name="output">stream to write Txt in.</param>
		/// <returns>0 on success</returns>
		public static int ToMatlabTxt(IECGFormat src, TextWriter output)
		{
			if ((src != null)
			&&	(output != null))
			{
				ISignal sigread = src.Signals;
				if (sigread != null)
				{
					Signals data;
					sigread.getSignals(out data);

					if ((data != null)
					&&	(data.NrLeads != 0)
					&&	(data.RhythmSamplesPerSecond != 0))
					{
						LeadType[] neededLeads = {LeadType.I, LeadType.II, LeadType.III, LeadType.aVR, LeadType.aVL, LeadType.aVF, LeadType.V1, LeadType.V2, LeadType.V3, LeadType.V4, LeadType.V5, LeadType.V6};
						output.Write("ECGStandardLeads = [");
						for (int find=0;find < neededLeads.Length;find++)
						{
							int p = 0;
							for (;p < data.NrLeads;p++)
							{
								if ((data[p] != null)
								&&	(data[p].Type == neededLeads[find])
								&&	(data[p].Rhythm != null))
								{
									break;
								}
							}
							if (p == data.NrLeads)
							{
								p = -1;
							}
							output.Write("{0} ", p+1);
						}
						output.WriteLine("];");
						output.WriteLine();

						if (data.MedianSamplesPerSecond != 0)
						{
							if (data.QRSZone != null)
							{
								output.Write("ECGSubtraction = [");
								int nr = 0;
								for (int loper=0;loper < data.QRSZone.Length;loper++)
								{
									if ((data.QRSZone[loper] != null)
									&&	(data.QRSZone[loper].Type == 0))
									{
										nr++;
										output.Write("{0} {1} {2} {3};",
										    data.QRSZone[loper].Start + 1,
										    data.MedianFiducialPoint + (data.QRSZone[loper].Start - data.QRSZone[loper].Fiducial) + 1,
										    data.QRSZone[loper].End,
										    data.MedianFiducialPoint + (data.QRSZone[loper].End - data.QRSZone[loper].Fiducial));
									}
								}
								output.WriteLine("];");
								output.WriteLine();
								output.WriteLine("ECGSubtractionNr = {0};", nr);
								output.WriteLine();
							}

							output.WriteLine("ECGMedianLength = {0};", (data.MedianLength * data.MedianSamplesPerSecond) / 1000);
							output.WriteLine();
						
					    	output.Write("ECGMedian = [");
							for (int sample=0;sample < (data.MedianLength * data.MedianSamplesPerSecond) / 1000;sample++)
							{
								for (int lead=0;lead < data.NrLeads;lead++)
								{
									if ((data[lead] != null)
									&&	(data[lead].Median != null)
									&&	(sample < data[lead].Median.Length))
									{
										output.Write(" {0}", data[lead].Median[sample] * data.MedianAVM);
									}
									else
									{
										output.Write(" 0");
									}
								}
								output.Write(";");
							}
							output.WriteLine("];");
							output.WriteLine();
							
							if (data.MedianSamplesPerSecond != data.RhythmSamplesPerSecond)
							{
								for (int lead=0;lead < data.NrLeads;lead++)
								{
									ECGTool.ResampleLead(data[lead].Rhythm, data.RhythmSamplesPerSecond, data.MedianSamplesPerSecond, out data[lead].Rhythm);
									data[lead].RhythmStart = (data[lead].RhythmStart * data.MedianSamplesPerSecond) / data.RhythmSamplesPerSecond;
									data[lead].RhythmEnd = (data[lead].RhythmEnd * data.MedianSamplesPerSecond) / data.RhythmSamplesPerSecond;
								}
							}
						}

						// Determine minimum start and maximum end.
						int minstart = int.MaxValue;
						int maxend = int.MinValue;
						for (int lead=0;lead < data.NrLeads;lead++)
						{
							if (data[lead] != null)
							{
								minstart = Math.Min(minstart, data[lead].RhythmStart);
								maxend = Math.Max(maxend, data[lead].RhythmEnd);
							}
						}

						output.WriteLine("ECGNrLeads = {0};", data.NrLeads);
						output.WriteLine();
						output.WriteLine("ECGNrSamples = {0};", maxend - minstart);
						output.WriteLine();

						output.Write("ECGRhythm = [");
						for (int sample=minstart;sample < maxend;sample++)
						{
							for (int lead=0;lead < data.NrLeads;lead++)
							{
								if ((data[lead] != null)
								&&	(data[lead].Rhythm != null)
								&&	(data[lead].Rhythm.Length >= (data[lead].RhythmEnd - data[lead].RhythmEnd))
								&&	(sample >= data[lead].RhythmStart)
								&&	(sample < data[lead].RhythmEnd))
								{
									output.Write(" {0}", data[lead].Rhythm[sample - data[lead].RhythmStart] * data.RhythmAVM);
								}
								else
								{
									output.Write(" 0");
								}
							}
							output.Write(";");
						}
						output.WriteLine("];");

						return 0;
					}
					return 4;
				}
				return 2;
			}
			return 1;
		}
		/// <summary>
		/// Enumeration to determine the part of converting that must be done.
		/// </summary>
		public enum ConvertWork
		{
			DoDemographics			= 0x01,
			DoSignal				= 0x02,
			DoDiagnostic			= 0x04,
			DoGlobalMeasurements	= 0x08,
			DoLeadMeasurements		= 0x10,
			DoAll					= 0x1f
		}
		/// <summary>
		/// Function to copy one ECG file to an other. (uses a couple of interfaces)
		/// </summary>
		/// <param name="src">source ECG file</param>
		/// <param name="dst">destination ECG file</param>
		/// <returns>0 on success</returns>
		public static int Convert(IECGFormat src, IECGFormat dst)
		{
			return Convert(src, dst, ConvertWork.DoAll);
		}
		/// <summary>
		/// Function to copy one ECG file to an other. (uses a couple of interfaces)
		/// </summary>
		/// <param name="src">source ECG file</param>
		/// <param name="dst">destination ECG file</param>
		/// <returns>0 on success</returns>
		public static int Convert(IECGFormat src, IECGFormat dst, ConvertWork cw)
		{
			_DemographicsError = 0;
			_DiagnosticError = 0;
			_GlobalMeasurementsError = 0;
			_SignalError = 0;
			_LeadMeasurementsError = 0;

			if (src == null)
			{
				return 1;
			}
			if (dst == null)
			{
				return 2;
			}

			if ((cw & ConvertWork.DoDemographics) != 0)
			{
				IDemographic demsrc = src.Demographics;
				IDemographic demdst = dst.Demographics;
				if ((demsrc != null)
				&&  (demdst != null))
				{
					demdst.Init();
					_DemographicsError = DemographicCopy(demsrc, demdst);
				}
			}

			if ((cw & ConvertWork.DoSignal) != 0)
			{
				ISignal sigsrc = src.Signals;
				ISignal sigdst = dst.Signals;
				if ((sigsrc != null)
				&&	(sigdst != null))
				{
					_SignalError = SignalCopy(sigsrc, sigdst);
				}
			}

			if ((cw & ConvertWork.DoDiagnostic) != 0)
			{
				IDiagnostic diasrc = src.Diagnostics;
				IDiagnostic diadst = dst.Diagnostics;
				if ((diasrc != null)
				&&  (diadst != null))
				{
					_DiagnosticError = DiagnosticCopy(diasrc, diadst);
				}
			}

			if ((cw & ConvertWork.DoGlobalMeasurements) != 0)
			{
				IGlobalMeasurement messrc = src.GlobalMeasurements;
				IGlobalMeasurement mesdst = dst.GlobalMeasurements;
				if ((messrc != null)
				&&  (mesdst != null))
				{
					_GlobalMeasurementsError = GlobalMeasurementCopy(messrc, mesdst);
				}
			}

			if ((cw & ConvertWork.DoLeadMeasurements) != 0)
			{
				ILeadMeasurement leadsrc = src.LeadMeasurements;
				ILeadMeasurement leaddst = dst.LeadMeasurements;
				if ((leadsrc != null)
				&&	(leaddst != null))
				{
					_LeadMeasurementsError = LeadMeasurementCopy(leadsrc, leaddst);
				}