dicomformat.cs

ecg tool kit for medical image retrieval system

/***************************************************************************
Copyright 2008, Thoraxcentrum, Erasmus MC, Rotterdam, The Netherlands

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Written by Maarten JB van Ettinger.

****************************************************************************/
using System;
using System.Collections;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;

using org.dicomcs.data;
using org.dicomcs.dict;

using Communication.IO.Tools;
using ECGConversion;
using ECGConversion.ECGDemographics;
using ECGConversion.ECGDiagnostic;
using ECGConversion.ECGGlobalMeasurements;
using ECGConversion.ECGSignals;

namespace ECGConversion.DICOM
{
	/// <summary>
	/// Summary description for DICOMFormat.
	/// </summary>
	public sealed class DICOMFormat : IECGFormat, ISignal, IDemographic, IDiagnostic, IGlobalMeasurement
	{
		private bool _MortaraCompat
		{
			get
			{
				return string.Compare(_Config["Mortara Compatibility"], "true", true) == 0;
			}
		}

		private string _UIDPrefix
		{
			get
			{
				string uidPrefix = _Config["UID Prefix"];

				return uidPrefix == null ? "1.2.826.0.1.34471.2.44.6." : uidPrefix;
			}
		}

		public Dataset DICOMData
		{
			get
			{
				return _DICOMData;
			}
		}

		private Dataset _DICOMData = null;
		private ushort _HighpassFilter = 0;
		private ushort _LowpassFilter = 0;
		private byte _FilterMap = 0;
		private ushort _FiducialPoint = 0;
		private QRSZone[] _QRSZone = null;

		public DICOMFormat()
		{
			Empty();

			string[] mustValue = {"Mortara Compatibility", "UID Prefix"};

			_Config = new ECGConfig(mustValue, null, new ECGConversion.ECGConfig.CheckConfigFunction(this._ConfigurationWorks));
			_Config["Mortara Compatibility"] = "false";
			_Config["UID Prefix"] = "1.2.826.0.1.34471.2.44.6.";
		}

		public DICOMFormat(Dataset ds) : this()
		{
			_DICOMData = ds;
		}

		public bool _ConfigurationWorks()
		{
			try
			{
				return (string.Compare(_Config["Mortara Compatibility"], "true", true) == 0)
					|| (string.Compare(_Config["Mortara Compatibility"], "false", true) == 0);
			}
			catch {}

			return false;
		}

		public override int Read(Stream input, int offset)
		{
			if (CheckFormat(_DICOMData))
				return 0;

			try
			{
				input.Seek(offset, SeekOrigin.Begin);
				DcmParser parser = new DcmParser(input);
			
				FileFormat ff = parser.DetectFileFormat();

				if (ff != null)
				{
					parser.DcmHandler = _DICOMData.DcmHandler;

					parser.ParseDcmFile(ff, Tags.PixelData);

					return CheckFormat(_DICOMData) ? 0 : 2;
				}
			}
			catch
			{
			}

			return 1;
		}
		public override int Read(string file, int offset)
		{
			if (CheckFormat(_DICOMData))
				return 0;

			FileStream stream = null;

			try
			{
				stream = new FileStream(file, FileMode.Open);

				return Read(stream, offset);
			}
			catch {}
			finally
			{
				if (stream != null)
				{
					stream.Close();
					stream = null;
				}
			}

			return 1;
		}
		public override int Read(byte[] buffer, int offset)
		{
			if (CheckFormat(_DICOMData))
				return 0;

			System.IO.MemoryStream ms = null;
			
			try
			{
				ms = new MemoryStream(buffer, offset, buffer.Length-offset, false);

				return Read(ms, 0);
			}
			catch {}
			finally
			{
				if (ms != null)
				{
					ms.Close();
					ms = null;
				}
			}

			return 2;
		}
		public override int Write(Stream output)
		{
			try
			{
				FileMetaInfo fmi = _DICOMData.GetFileMetaInfo();

				if (fmi != null)
				{
					DcmEncodeParam param = DcmDecodeParam.ValueOf(fmi.GetString(Tags.TransferSyntaxUID));

					if (_MortaraCompat)
					{
						param = new DcmEncodeParam(org.dicomcs.util.ByteOrder.LITTLE_ENDIAN, false, false, false, true, false, false);

						fmi.PutUI(Tags.TransferSyntaxUID, UIDs.ImplicitVRLittleEndian);
					}

					_DICOMData.WriteFile(output, param);
				}
				else
				{
					_DICOMData.WriteFile(output, org.dicomcs.data.DcmEncodeParam.EVR_LE);
				}

				return 0;
			}
			catch {}

			return 1;
		}
		public override int Write(string file)
		{
			FileStream output = null;

			try
			{
				output = new FileStream(file, FileMode.Create);

				return Write(output);
			}
			catch {}
			finally
			{
				if (output != null)
				{
					output.Close();
					output = null;
				}
			}

			return 1;
		}
		public override int Write(byte[] buffer, int offset)
		{
			System.IO.MemoryStream ms = null;
			
			try
			{
				ms = new MemoryStream(buffer, offset, buffer.Length-offset, true);

				return Write(ms);
			}
			catch {}
			finally
			{
				if (ms != null)
				{
					ms.Close();
					ms = null;
				}
			}

			return 2;
		}
		public bool CheckFormat(Dataset ds)
		{
			if (ds == null)
				return false;

			bool ret = false;

			switch (ds.GetString(Tags.SOPClassUID))
			{
				case UIDs.WaveformStorageTrialRetired:
				case UIDs.HemodynamicWaveformStorage:
				case UIDs.TwelveLeadECGWaveformStorage:
				case UIDs.GeneralECGWaveformStorage:
					ret = true;
					break;
				default:
					break;
			}

			ret = ret &&  (string.Compare(ds.GetString(Tags.Modality), "ECG") == 0);

			if (!ret)
			{
				Empty();
			}

			return ret;
		}
		public override bool CheckFormat(Stream input, int offset)
		{
			try
			{
				input.Seek(offset, SeekOrigin.Begin);

				DcmParser parser = new DcmParser(input);
			
				FileFormat ff = parser.DetectFileFormat();

				if (ff != null)
				{
					parser.DcmHandler = _DICOMData.DcmHandler;

					parser.ParseDcmFile(ff, Tags.PixelData);

					return CheckFormat(_DICOMData);
				}
			}
			catch {}

			return false;
		}
		public override bool CheckFormat(string file, int offset)
		{
			FileStream stream = null;

			try
			{
				stream = new FileStream(file, FileMode.Open);

				return CheckFormat(stream, offset);
			}
			catch {}
			finally
			{
				if (stream != null)
				{
					stream.Close();
					stream = null;
				}
			}

			return false;
		}
		public override bool CheckFormat(byte[] buffer, int offset)
		{
			System.IO.MemoryStream ms = null;
			
			try
			{
				ms = new MemoryStream(buffer, offset, buffer.Length-offset, false);

				return CheckFormat(ms, 0);
			}
			catch {}
			finally
			{
				if (ms != null)
				{
					ms.Close();
					ms = null;
				}
			}

			return false;
		}
		public override IDemographic Demographics
		{
			get
			{
				return this;
			}
		}
		public override IDiagnostic Diagnostics
		{
			get
			{
				return this;
			}
		}
		public override IGlobalMeasurement GlobalMeasurements
		{
			get
			{
				return this;
			}
		}
		public override ISignal Signals
		{
			get
			{
				return this;
			}
		}
		public override void Anonymous(byte type)
		{
			ECGTool.Anonymous(this, (char)type);
		}
		public override int getFileSize()
		{
			return -1;
		}
		public override bool Works()
		{
			return CheckFormat(_DICOMData);
		}
		public override void Empty()
		{
			_DICOMData = new Dataset();
		}

		#region IDisposable Members
		public override void Dispose()
		{
			base.Dispose();

			_DICOMData = null;
		}
		#endregion

		#region ISignal Members

		public int getSignals(out Signals signals)
		{
			signals = new Signals();
			int err = getSignalsToObj(signals);
			if (err != 0)
			{
				signals = null;
			}
			return err;
		}

		public int getSignalsToObj(Signals signals)
		{
			DcmElement waveformElement = _DICOMData.Get(Tags.WaveformSeq);

			try
			{
				if (waveformElement != null
				&&	waveformElement.HasItems())
				{
					Dataset waveformSet = waveformElement.GetItem(0);

					if (string.Compare(waveformSet.GetString(Tags.WaveformOriginality), "ORIGINAL", true) != 0)
						return 2;

					signals.NrLeads = (byte) waveformSet.GetInteger(Tags.NumberOfWaveformChannels);
                    int nrSamples = (int) waveformSet.GetInteger(Tags.NumberOfWaveformSamples);
					signals.RhythmSamplesPerSecond = int.Parse(waveformSet.GetString(Tags.SamplingFrequency), System.Globalization.CultureInfo.InvariantCulture.NumberFormat);

					int ret = GetWaveform(signals, waveformSet.Get(Tags.ChannelDefInitionSeq), waveformSet.GetInts(Tags.WaveformData), nrSamples, false);

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

					if (waveformSet.GetInts(Tags.WaveformPaddingValue) != null)
						signals.TrimSignals((short) waveformSet.GetInteger(Tags.WaveformPaddingValue));

					if (waveformElement.vm() == 2)
					{
						waveformSet = waveformElement.GetItem(1);

						if ((string.Compare(waveformSet.GetString(Tags.WaveformOriginality), "DERIVED", true) == 0)
						&&	(signals.NrLeads == waveformSet.GetInteger(Tags.NumberOfWaveformChannels)))
						{
							nrSamples = (int) waveformSet.GetInteger(Tags.NumberOfWaveformSamples);
							signals.MedianSamplesPerSecond = int.Parse(waveformSet.GetString(Tags.SamplingFrequency), System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
							signals.MedianLength = (ushort) ((1000 * nrSamples) / signals.MedianSamplesPerSecond);

							ret = GetWaveform(signals, waveformSet.Get(Tags.ChannelDefInitionSeq), waveformSet.GetInts(Tags.WaveformData), nrSamples, true);

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

					return 0;
				}
			}
			catch {}
			return 1;
		}

		public int setSignals(Signals signals)
		{
			Signals sigs = signals.CalculateTwelveLeads();

			if (sigs != null)
			{
				int start, end;

				sigs.CalculateStartAndEnd(out start, out end);

				if ((end - start) <= 16384)
				{
					FileMetaInfo fmi = _DICOMData.GetFileMetaInfo();

					if (fmi != null)
						fmi.PutUI(Tags.MediaStorageSOPClassUID, UIDs.TwelveLeadECGWaveformStorage);

					_DICOMData.PutUI(Tags.SOPClassUID, UIDs.TwelveLeadECGWaveformStorage);
				}

				signals = sigs;
			}

			_FiducialPoint = signals.MedianFiducialPoint;
			_QRSZone = signals.QRSZone;

			DcmElement waveformElement = _DICOMData.PutSQ(Tags.WaveformSeq);

			Dataset waveformSet = waveformElement.AddNewItem();

			int ret = SetWaveform(waveformSet, signals, false);

			if (ret != 0)
				return ret;

			if ((signals.MedianAVM != 0.0)
			&&	(signals.MedianSamplesPerSecond != 0)
			&&	(signals.MedianLength != 0))
			{
				waveformSet = waveformElement.AddNewItem();

				return SetWaveform(waveformSet, signals, true);
			}

            return 0;
		}

		#endregion

		#region IDemographic Members
		public void Init()
		{
			Empty();

			try
			{
				FileMetaInfo fmi = new FileMetaInfo();

				fmi.PutOB(Tags.FileMetaInformationVersion, new byte[] {0, 1});
				fmi.PutUI(Tags.MediaStorageSOPClassUID, UIDs.GeneralECGWaveformStorage);
				fmi.PutUI(Tags.MediaStorageSOPInstanceUID, "1.3.6.1.4.1.1.24.04.1985");
				fmi.PutUI(Tags.TransferSyntaxUID, (_MortaraCompat ? UIDs.ImplicitVRLittleEndian : UIDs.ExplicitVRLittleEndian));
				fmi.PutUI(Tags.ImplementationClassUID, "2.24.985.4");
				fmi.PutSH(Tags.ImplementationVersionName, "ECGConversion2");

				_DICOMData.SetFileMetaInfo(fmi);

				_DICOMData.PutDA(Tags.InstanceCreationDate, DateTime.Now);
				_DICOMData.PutTM(Tags.InstanceCreationTime, DateTime.Now);
				_DICOMData.PutUI(Tags.SOPClassUID, UIDs.GeneralECGWaveformStorage);
				_DICOMData.PutUI(Tags.SOPInstanceUID, "1.3.6.1.4.1.1.24.04.1985");
				_DICOMData.PutDA(Tags.StudyDate, "");
				_DICOMData.PutDA(Tags.ContentDate, "");
				_DICOMData.PutDT(Tags.AcquisitionDatetime, "");
				_DICOMData.PutTM(Tags.StudyTime, "");
				_DICOMData.PutTM(Tags.ContentTime, "");
				_DICOMData.PutSH(Tags.AccessionNumber, "");
				_DICOMData.PutCS(Tags.Modality, "ECG");
				_DICOMData.PutLO(Tags.Manufacturer, "");
				_DICOMData.PutPN(Tags.ReferringPhysicianName, "");
				_DICOMData.PutPN(Tags.NameOfPhysicianReadingStudy, "");
				_DICOMData.PutPN(Tags.OperatorName, "");
				_DICOMData.PutLO(Tags.ManufacturerModelName, "");
				_DICOMData.PutPN(Tags.PatientName, "");
				_DICOMData.PutLO(Tags.PatientID, "");
				_DICOMData.PutDA(Tags.PatientBirthDate, "");
				_DICOMData.PutCS(Tags.PatientSex, "");
				_DICOMData.PutLO(Tags.OtherPatientIDs, "");