scpsection4.cs

来自「ecg tool kit for medical image retrieval」· CS 代码 · 共 681 行 · 第 1/2 页

		{
			if ((_Protected != null)
			&&  (nr >= 0)
			&&	(nr < _Protected.Length))
			{
				return _Protected[nr].End;
			}
			return -1;
		}
		/// <summary>
		/// Function to get length of protected zone.
		/// </summary>
		/// <param name="nr">nr of protected zone</param>
		/// <returns>length of protected zone in samples</returns>
		public int getProtectedLength(int nr)
		{
			if ((_Protected != null)
			&&  (nr >= 0)
			&&	(nr < _Protected.Length))
			{
				if (_Protected[nr] == null)
				{
					return 0;
				}

				int templen = _Protected[nr].End - _Protected[nr].Start;
				return (templen > 0 ? templen + 1 : 0);
			}
			return -1;
		}
		/// <summary>
		/// Function to set protected zones using global measurements.
		/// </summary>
		/// <param name="global">global measurments</param>
		/// <param name="medianFreq">Samples per Second of median</param>
		/// <param name="rate">Bimodal compression rate</param>
		/// <param name="minbegin">Begin of all leads in samples</param>
		/// <param name="maxend">End of all leads in samples</param>
		public void setProtected(GlobalMeasurements global, int medianFreq, int rate, int minbegin, int maxend)
		{
			if ((global != null)
			&&	(global.measurment != null)
			&&	(_Subtraction != null)
			&&	(_Protected != null)
			&&	(medianFreq != 0))
			{
				// If global measurements are per beat use them.
				if (global.measurment.Length == (_Protected.Length + 1))
				{
					for (int loper=0;loper < _Protected.Length;loper++)
					{
						_Protected[loper].Start = _Subtraction[loper].Fiducial + (short) ((global.measurment[loper + 1].QRSonset - (_FirstFiducial * 1000)) / medianFreq);
						_Protected[loper].End = _Subtraction[loper].Fiducial + (short) ((global.measurment[loper + 1].QRSoffset - (_FirstFiducial * 1000)) / medianFreq);

						// Make protected zones work properly
						_Protected[loper].Start -= ((_Protected[loper].Start % rate) == 0 ? rate : (_Protected[loper].Start % rate));
						_Protected[loper].Start++;
						_Protected[loper].End += (rate - (_Protected[loper].End % rate));

						// Keep it all between boundaries of ECG.
						if (_Protected[loper].Start < minbegin)
						{
							_Protected[loper].Start = minbegin;
						}
						if (_Protected[loper].End > maxend)
						{
							_Protected[loper].End = maxend;
						}
					}
				}
				else if (global.measurment.Length > 0)
				{
					for (int loper=0;loper < _Protected.Length;loper++)
					{
						if (_Subtraction[loper].Type == 0)
						{
							_Protected[loper].Start = _Subtraction[loper].Fiducial + (short) ((global.measurment[0].QRSonset * medianFreq) / 1000) - _FirstFiducial;
							_Protected[loper].End = _Subtraction[loper].Fiducial + (short) ((global.measurment[0].QRSoffset * medianFreq) / 1000) - _FirstFiducial;
						}

						// Make protected zones work properly
						_Protected[loper].Start -= ((_Protected[loper].Start % rate) == 0 ? rate : (_Protected[loper].Start % rate));
						_Protected[loper].Start++;
						_Protected[loper].End += (rate - (_Protected[loper].End % rate));

						// Keep it all between boundaries of ECG.
						if (_Protected[loper].Start < minbegin)
						{
							_Protected[loper].Start = minbegin;
						}
						if (_Protected[loper].End > maxend)
						{
							_Protected[loper].End = maxend;
						}
					}
				}
			}
		}
		// Signal Manupalations
		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)
		{
			if (signals != null
			&&  Works())
			{
				signals.MedianLength = _MedianDataLength;
				signals.MedianFiducialPoint = _FirstFiducial;

				if (_NrQRS == 0)
				{
					signals.QRSZone = null;
				}
				else
				{
					signals.QRSZone = new QRSZone[_NrQRS];
					for (int loper = 0;loper < _NrQRS;loper++)
					{
						signals.QRSZone[loper] = new QRSZone();
						if (_Subtraction[loper] != null)
						{
							signals.QRSZone[loper].Type = _Subtraction[loper].Type;
							signals.QRSZone[loper].Start = _Subtraction[loper].Start - 1;
							signals.QRSZone[loper].Fiducial = _Subtraction[loper].Fiducial;
							signals.QRSZone[loper].End = _Subtraction[loper].End;
						}
					}
				}

				return 0;
			}
			return 1;
		}
		public int setSignals(Signals signals)
		{
			if ((signals != null)
			&&  (signals.NrLeads != 0))
			{
				_MedianDataLength = signals.MedianLength;
				_FirstFiducial = signals.MedianFiducialPoint;

				if (signals.QRSZone == null)
				{
					_NrQRS = 0;
					_Subtraction = null;
					_Protected = null;
				}
				else
				{
					_NrQRS = (ushort) signals.QRSZone.Length;
					_Subtraction = new SCPQRSSubtraction[_NrQRS];
					_Protected = new SCPQRSProtected[_NrQRS];

					for (int loper=0;loper < _NrQRS;loper++)
					{
						_Subtraction[loper] = new SCPQRSSubtraction();
						_Protected[loper] = new SCPQRSProtected();

						if (signals.QRSZone[loper] != null)
						{
							_Subtraction[loper].Type = signals.QRSZone[loper].Type;
							_Subtraction[loper].Fiducial = signals.QRSZone[loper].Fiducial;

							if (_Subtraction[loper].Type == 0)
							{
								_Subtraction[loper].Start = signals.QRSZone[loper].Start + 1;
								_Subtraction[loper].End = signals.QRSZone[loper].End;

								if (((_Subtraction[loper].End - _Subtraction[loper].Fiducial) + _FirstFiducial)
								>=	((signals.MedianLength * signals.MedianSamplesPerSecond) / 1000))
								{
									_Subtraction[loper].End = (int) (((((signals.MedianLength * signals.MedianSamplesPerSecond) / 1000) - _FirstFiducial) + _Subtraction[loper].Fiducial - 2) & 0xfffffffe);
								}

								_Protected[loper].Start = _Subtraction[loper].Start;
								_Protected[loper].End = _Subtraction[loper].End;
							}
							else
							{
							}
						}
					}
				}

				return 0;
			}
			return 1;
		}
		/// <summary>
		/// Class containing SCP QRS subtraction zone.
		/// </summary>
		[StructLayout(LayoutKind.Sequential, Pack=1, CharSet=CharSet.Ansi)]
		public class SCPQRSSubtraction
		{
			public ushort Type = ushort.MaxValue;
			public int Start = 0;
			public int Fiducial = 0;
			public int End = 0;
			/// <summary>
			/// Constructor for an QRS Subtraction zone.
			/// </summary>
			public SCPQRSSubtraction()
			{}
			/// <summary>
			/// Constructor for an QRS Subtraction zone.
			/// </summary>
			/// <param name="type">type of subtraction</param>
			/// <param name="start">starting point of subtraction zone</param>
			/// <param name="fiducial">fiducial point in subtraction zone</param>
			/// <param name="end">ending point of subtraction zone</param>
			public SCPQRSSubtraction(byte type, int start, int fiducial, int end)
			{
				Type = type;
				Start = start;
				Fiducial = fiducial;
				End = end;
			}
			/// <summary>
			/// Function to read QRS Subtraction.
			/// </summary>
			/// <param name="buffer">byte array to read QRS subtraction.</param>
			/// <param name="offset">position to start reading</param>
			/// <returns>0 on success</returns>
			public int Read(byte[] buffer, int offset)
			{
				if (offset + Marshal.SizeOf(this) > buffer.Length)
				{
					return 0x1;
				}

				Type = (ushort) BytesTool.readBytes(buffer, offset, Marshal.SizeOf(Type), true);
				offset += Marshal.SizeOf(Type);
				Start = (int) BytesTool.readBytes(buffer, offset, Marshal.SizeOf(Start), true);
				offset += Marshal.SizeOf(Start);
				Fiducial = (int) BytesTool.readBytes(buffer, offset, Marshal.SizeOf(Fiducial), true);
				offset += Marshal.SizeOf(Fiducial);
				End = (int) BytesTool.readBytes(buffer, offset, Marshal.SizeOf(End), true);
				offset += Marshal.SizeOf(End);

				return 0x0;
			}
			/// <summary>
			/// Function to write QRS Subtraction zone.
			/// </summary>
			/// <param name="buffer">byte array</param>
			/// <param name="offset">position to start writing</param>
			/// <returns>0 on success</returns>
			public int Write(byte[] buffer, int offset)
			{
				if (offset + Marshal.SizeOf(this) > buffer.Length)
				{
					return 0x1;
				}

				BytesTool.writeBytes(Type, buffer, offset, Marshal.SizeOf(Type), true);
				offset += Marshal.SizeOf(Type);
				BytesTool.writeBytes(Start, buffer, offset, Marshal.SizeOf(Start), true);
				offset += Marshal.SizeOf(Start);
				BytesTool.writeBytes(Fiducial, buffer, offset, Marshal.SizeOf(Fiducial), true);
				offset += Marshal.SizeOf(Fiducial);
				BytesTool.writeBytes(End, buffer, offset, Marshal.SizeOf(End), true);
				offset += Marshal.SizeOf(End);

				return 0x0;
			}
		}
		/// <summary>
		/// Class containing QRS protected zones.
		/// </summary>
		[StructLayout(LayoutKind.Sequential, Pack=1, CharSet=CharSet.Ansi)]
		public class SCPQRSProtected
		{
			public int Start = 0;
			public int End = 0;
			/// <summary>
			/// Constructor to create an QRS protected zone.
			/// </summary>
			public SCPQRSProtected()
			{}
			/// <summary>
			/// Constructor to create an QRS protected zone.
			/// </summary>
			/// <param name="start">start sample of zone</param>
			/// <param name="end">end sample of zone</param>
			public SCPQRSProtected(int start, int end)
			{
				Start = start;
				End = end;
			}
			/// <summary>
			/// Function to read QRS protected zone.
			/// </summary>
			/// <param name="buffer">byte array to read from</param>
			/// <param name="offset">position to start reading</param>
			/// <returns>0 on success</returns>
			public int Read(byte[] buffer, int offset)
			{
				if (offset + Marshal.SizeOf(this) > buffer.Length)
				{
					return 0x1;
				}

				Start = (int) BytesTool.readBytes(buffer, offset, Marshal.SizeOf(Start), true);
				offset += Marshal.SizeOf(Start);
				End = (int) BytesTool.readBytes(buffer, offset, Marshal.SizeOf(End), true);
				offset += Marshal.SizeOf(End);

				return 0x0;
			}
			/// <summary>
			/// Function to write QRS protected zone.
			/// </summary>
			/// <param name="buffer">byte array to write to</param>
			/// <param name="offset">position to start writing</param>
			/// <returns>0 on success</returns>
			public int Write(byte[] buffer, int offset)
			{
				if (offset + Marshal.SizeOf(this) > buffer.Length)
				{
					return 0x1;
				}

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

				return 0x0;
			}
		}
	}
}