scpsection7.cs

ecg tool kit for medical image retrieval system

/***************************************************************************
Copyright 2004, 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.Runtime.InteropServices;
using Communication.IO.Tools;
using ECGConversion.ECGGlobalMeasurements;

namespace ECGConversion.SCP
{
	/// <summary>
	/// Class contains section 7 (contains the global measurements section).
	/// </summary>
	public class SCPSection7 : SCPSection, IGlobalMeasurement
	{
		// Defined in SCP.
		private static ushort _SectionID = 7;

		// Special variables for this section.
		private bool _AfterSpikes = false;
		private bool _AfterSpikesInfo = false;
		private bool _AfterQRSType = false;

		// Part of the stored Data Structure.
		private byte _NrRefTypeQRS = 0;
		private byte _NrSpikes = 0;
		private ushort _AvgRRInterval = 0;
		private ushort _AvgPPInterval = 0;
		private SCPMeasurement[] _Measurements = null;
		private SCPSpike[] _Spikes = null;
		private SCPSpikeInfo[] _SpikesInfo = null;
		private ushort _NrQRS = 0;
		private byte[] _QRSType = null;
		private SCPExtraMeasurements _ExtraMeasurements = new SCPExtraMeasurements();

		// Manufactor specific block (Not implemented, because UNIPRO doesn't store this kind of info).
		private byte[] _Rest = null;

		protected override int _Read(byte[] buffer, int offset)
		{
			_AfterSpikes = true;
			_AfterSpikesInfo = true;
			_AfterQRSType = true;
			int end = offset - Size + Length;
			int frontsize = Marshal.SizeOf(_NrRefTypeQRS) + Marshal.SizeOf(_NrSpikes) + Marshal.SizeOf(_AvgRRInterval) + Marshal.SizeOf(_AvgPPInterval);
			if ((offset + frontsize) > end)
			{
				return 0x1;
			}

			_NrRefTypeQRS = (byte) BytesTool.readBytes(buffer, offset, Marshal.SizeOf(_NrRefTypeQRS), true);
			offset += Marshal.SizeOf(_NrRefTypeQRS);
			_NrSpikes = (byte) BytesTool.readBytes(buffer, offset, Marshal.SizeOf(_NrSpikes), true);
			offset += Marshal.SizeOf(_NrSpikes);
			_AvgRRInterval = (ushort) BytesTool.readBytes(buffer, offset, Marshal.SizeOf(_AvgRRInterval), true);
			offset += Marshal.SizeOf(_AvgRRInterval);
			_AvgPPInterval = (ushort) BytesTool.readBytes(buffer, offset, Marshal.SizeOf(_AvgPPInterval), true);
			offset += Marshal.SizeOf(_AvgPPInterval);

			if (_NrRefTypeQRS > 0)
			{
				if ((offset + (_NrRefTypeQRS * Marshal.SizeOf(typeof(SCPMeasurement)))) > end)
				{
					return 0x2;
				}
				_Measurements = new SCPMeasurement[_NrRefTypeQRS];
				for (int loper=0;loper < _NrRefTypeQRS;loper++)
				{
					_Measurements[loper] = new SCPMeasurement();
					_Measurements[loper].Read(buffer, offset);
					offset += Marshal.SizeOf(_Measurements[loper]);
				}
			}
			if (_NrSpikes > 0)
			{
				if ((offset + (_NrSpikes * Marshal.SizeOf(typeof(SCPSpike)))) > end)
				{
					return 0x4;
				}
				_Spikes = new SCPSpike[_NrSpikes];
				for (int loper=0;loper < _NrSpikes;loper++)
				{
					_Spikes[loper] = new SCPSpike();
					_Spikes[loper].Read(buffer, offset);
					offset += Marshal.SizeOf(_Spikes[loper]);
				}
				if (offset + (_NrSpikes * Marshal.SizeOf(typeof(SCPSpikeInfo))) > end)
				{
					_AfterSpikes = false;
					_AfterSpikesInfo = false;
					_AfterQRSType = false;
					return 0x0;
				}
				_SpikesInfo = new SCPSpikeInfo[_NrSpikes];
				for (int loper=0;loper < _NrSpikes;loper++)
				{
					_SpikesInfo[loper] = new SCPSpikeInfo();
					_SpikesInfo[loper].Read(buffer, offset);
					offset += Marshal.SizeOf(_SpikesInfo[loper]);
				}
			}
			
			if ((offset + Marshal.SizeOf(_NrQRS)) > end)
			{
				_AfterSpikesInfo = false;
				_AfterQRSType = false;
				return 0x0;
			}

			_NrQRS = (ushort) BytesTool.readBytes(buffer, offset, Marshal.SizeOf(_NrQRS), true);
			offset += Marshal.SizeOf(_NrQRS);

			if (_NrQRS > 0)
			{
				if ((offset + (_NrQRS * Marshal.SizeOf(typeof(byte)))) > end)
				{
					return 0x10;
				}
				_QRSType = new byte[_NrQRS];
				for (int loper=0;loper < _NrQRS;loper++)
				{
					_QRSType[loper] = (byte) BytesTool.readBytes(buffer, offset, Marshal.SizeOf(_QRSType[loper]), true);
					offset += Marshal.SizeOf(_QRSType[loper]);
				}
			}

			int err = _ExtraMeasurements.Read(buffer, offset);
			offset += _ExtraMeasurements.getLength();
			if ((err != 0)
			||  (offset > end))
			{
				_AfterQRSType = false;
				_ExtraMeasurements.Empty();
				return 0x20;
			}

			if ((end - offset) > 0)
			{
				_Rest = new byte[end - offset];
				offset += BytesTool.copy(_Rest, 0, buffer, offset, _Rest.Length);
			}

			return 0x0;
		}
		protected override int _Write(byte[] buffer, int offset)
		{
			BytesTool.writeBytes(_NrRefTypeQRS, buffer, offset, Marshal.SizeOf(_NrRefTypeQRS), true);
			offset += Marshal.SizeOf(_NrRefTypeQRS);
			BytesTool.writeBytes(_NrSpikes, buffer, offset, Marshal.SizeOf(_NrSpikes), true);
			offset += Marshal.SizeOf(_NrSpikes);
			BytesTool.writeBytes(_AvgRRInterval, buffer, offset, Marshal.SizeOf(_AvgRRInterval), true);
			offset += Marshal.SizeOf(_AvgRRInterval);
			BytesTool.writeBytes(_AvgPPInterval, buffer, offset, Marshal.SizeOf(_AvgPPInterval), true);
			offset += Marshal.SizeOf(_AvgPPInterval);

			if (_NrRefTypeQRS > 0)
			{
				for (int loper=0;loper < _NrRefTypeQRS;loper++)
				{
					int err = _Measurements[loper].Write(buffer, offset);
					if (err != 0)
					{
						return 0x1;
					}
					offset += Marshal.SizeOf(_Measurements[loper]);
				}
			}
			if (_NrSpikes > 0)
			{
				for (int loper=0;loper < _NrSpikes;loper++)
				{
					int err = _Spikes[loper].Write(buffer, offset);
					if (err != 0)
					{
						return 0x2;
					}
					offset += Marshal.SizeOf(_Spikes[loper]);
				}
				if (!_AfterSpikes)
				{
					return 0;
				}
				for (int loper=0;loper < _NrSpikes;loper++)
				{
					int err = _SpikesInfo[loper].Write(buffer, offset);
					if (err != 0)
					{
						return 0x4;
					}
					offset += Marshal.SizeOf(_SpikesInfo[loper]);
				}
			}

			if (!_AfterSpikesInfo)
			{
				return 0;
			}

			BytesTool.writeBytes(_NrQRS, buffer, offset, Marshal.SizeOf(_NrQRS), true);
			offset += Marshal.SizeOf(_NrQRS);

			if ((_NrQRS > 0)
			&&  (_QRSType != null))
			{
				for (int loper=0;loper < _NrQRS;loper++)
				{
					BytesTool.writeBytes(_QRSType[loper], buffer, offset, Marshal.SizeOf(_QRSType[loper]), true);
					offset += Marshal.SizeOf(_QRSType[loper]);
				}
			}

			if (!_AfterQRSType)
			{
				return 0;
			}

			if (_ExtraMeasurements != null)
			{
				int err = _ExtraMeasurements.Write(buffer, offset);
				if (err != 0)
				{
					return 0x8;
				}
				offset += _ExtraMeasurements.getLength();
			}

			if ((_Rest != null)
			&&  ((offset + _Rest.Length) < buffer.Length))
			{
				offset += BytesTool.copy(_Rest, 0, buffer, offset, _Rest.Length);
			}
			return 0x0;
		}
		protected override void _Empty()
		{
			_NrRefTypeQRS = 0;
			_NrSpikes = 0;
			_AvgRRInterval = 0;
			_AvgPPInterval = 0;
			_Measurements = null;
			_Spikes = null;
			_SpikesInfo = null;
			_AfterSpikes = false;
			_NrQRS = 0;
			_AfterQRSType = false;
			_QRSType = null;
			_ExtraMeasurements.Empty();
			_Rest = null;
		}
		protected override int _getLength()
		{
			if (Works())
			{
				int sum = Marshal.SizeOf(_NrRefTypeQRS) + Marshal.SizeOf(_NrSpikes) + Marshal.SizeOf(_AvgPPInterval) + Marshal.SizeOf(_AvgRRInterval);
				sum += (_NrRefTypeQRS * Marshal.SizeOf(typeof(SCPMeasurement)));
				sum += (_NrSpikes * (Marshal.SizeOf(typeof(SCPSpike)) + Marshal.SizeOf(typeof(SCPSpikeInfo))));
				if (_AfterSpikes)
				{
					sum += Marshal.SizeOf(_NrQRS) + (_NrQRS * Marshal.SizeOf(typeof(byte)));
					if (_AfterQRSType)
					{
						sum += _ExtraMeasurements.getLength();
						if (_Rest != null)
						{
							sum += _Rest.Length;
						}
					}
				}
				return sum;
			}
			return 0;
		}
		public override ushort getSectionID()
		{
			return _SectionID;
		}
		public override bool Works()
		{
			if ((_NrRefTypeQRS == 0)
			||	((_Measurements != null)
			&&	 (_Measurements.Length == _NrRefTypeQRS)))
			{
				if ((_NrSpikes == 0)
				||  ((_Spikes != null)
				&&	 (_Spikes.Length == _NrSpikes)))
				{
					if (!_AfterSpikes)
					{
						return ((_NrRefTypeQRS != 0) || (_NrSpikes != 0));
					}

					if ((_SpikesInfo != null)
					&&  (_SpikesInfo.Length == _NrSpikes))
					{
						if (!_AfterSpikesInfo)
						{
							return ((_NrRefTypeQRS != 0) || (_NrSpikes != 0));
						}

						if ((_NrQRS == 0)
						||  ((_QRSType != null)
						&&	 (_QRSType.Length == _NrQRS)))
						{
							return (!_AfterQRSType
								||	(_ExtraMeasurements != null));
						}
					}
				}
				return true;
			}
			return false;
		}
		public int getGlobalMeasurements(out GlobalMeasurements mes)
		{
			mes = null;
			if (Works())
			{
				mes = new GlobalMeasurements();
				mes.AvgRR = _AvgRRInterval;
				mes.AvgPP = _AvgPPInterval;
				mes.measurment = new GlobalMeasurement[_NrRefTypeQRS];
				for (int loper=0;loper < _NrRefTypeQRS;loper++)
				{
					mes.measurment[loper] = new GlobalMeasurement();
					if (_Measurements[loper] != null)
					{
						mes.measurment[loper].Ponset = _Measurements[loper].Ponset;
						mes.measurment[loper].Poffset = _Measurements[loper].Poffset;
						mes.measurment[loper].QRSonset = _Measurements[loper].QRSonset;
						mes.measurment[loper].QRSoffset = _Measurements[loper].QRSoffset;
						mes.measurment[loper].Toffset = _Measurements[loper].Toffset;
						mes.measurment[loper].Paxis = _Measurements[loper].Paxis;
						mes.measurment[loper].QRSaxis= _Measurements[loper].QRSaxis;
						mes.measurment[loper].Taxis = _Measurements[loper].Taxis;
					}
				}

				if (_NrSpikes > 0)
				{
					mes.spike = new Spike[_NrSpikes];
					for (int loper=0;loper < _NrSpikes;loper++)
					{
						mes.spike[loper] = new Spike();
						mes.spike[loper].Time = _Spikes[loper].Time;
						mes.spike[loper].Amplitude = _Spikes[loper].Amplitude;
					}
				}

				if (_AfterQRSType)
				{
					mes.VentRate = _ExtraMeasurements.VentRate;

					switch (_ExtraMeasurements.FormulaType)
					{
						case 1: case 2:
							mes.QTcType = (GlobalMeasurements.QTcCalcType) (_ExtraMeasurements.FormulaType - 1);
							break;
						default:
							mes.QTc = _ExtraMeasurements.QTc;
							break;
					}
				}

				return 0;
			}
			return 1;
		}
		public int setGlobalMeasurements(GlobalMeasurements mes)