scpformat.cs

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

			&&  (_Default[0] is SCPSection0))
			{
				SCPSection0 pointers = (SCPSection0) _Default[0];
				int sum = Marshal.SizeOf(_CRC) + Marshal.SizeOf(_Length);
				for (int loper=0;loper < pointers.getNrPointers();loper++)
				{
					sum += pointers.getLength(loper);
				}
				return sum;
			}
			return 0;
		}
		public override IDemographic Demographics
		{
			get
			{
				if (_Default[1] is SCPSection1)
					return (SCPSection1)_Default[1];

				return null;
			}
		}
		public override IDiagnostic Diagnostics
		{
			get
			{
				if (_Default[8] is SCPSection8)
					return (SCPSection8) _Default[8];

				return null;
			}
		}
		public override IGlobalMeasurement GlobalMeasurements
		{
			get
			{
				if (_Default[7] is SCPSection7)
					return (SCPSection7) _Default[7];

				return null;
			}
		}
		public override ISignal Signals
		{
			get
			{
				return this;
			}
		}

		public override ECGConversion.ECGLeadMeasurements.ILeadMeasurement LeadMeasurements
		{
			get
			{
				if (_UseLeadMeasurements
				&&	(_Default[10] is SCPSection10))
					return (SCPSection10) _Default[10];

				return null;
			}
		}


		public override bool Works()
		{
			if ((_Default.Length == _MinNrSections)
			&&  (_Default[0] is SCPSection0)
			&&  (_MinNrSections + (_Manufactor != null ? _Manufactor.Length : 0)) == ((SCPSection0)_Default[0]).getNrPointers())
			{
				for (int loper=0;loper < _MinNrWorkingSections;loper++)
				{
					if (_Default[loper] == null)
					{
						return false;
					}
				}
				return (_Default[0].Works() &&  _Default[1].Works());
			}
			return false;
		}
		public override void Empty()
		{
			EmptyFormat();
		}
		#endregion
		#region ISignal Members
		// 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)
			{
				if (((ISignal)_Default[3]).getSignalsToObj(signals) != 0)
				{
					return 2;
				}

				short[][] medianData = null;
				if (((ISignal)_Default[4]).getSignalsToObj(signals) == 0)
				{
					SCPSection5 median = (SCPSection5) _Default[5];
					
					if (median == null)
					{
						return 4;
					}

					medianData = median.DecodeData((SCPSection2) _Default[2], signals.MedianLength);

					signals.MedianAVM = median.getAVM();
					signals.MedianSamplesPerSecond = median.getSamplesPerSecond();

					for (int loper=0;loper < signals.NrLeads;loper++)
					{
						signals[loper].Median = medianData[loper];
					}
				}

				SCPSection6 rhythm = (SCPSection6) _Default[6];
				short[][] rhythmData = rhythm.DecodeData((SCPSection2) _Default[2], (SCPSection3) _Default[3], (SCPSection4) _Default[4], ((SCPSection5) _Default[5]).getSamplesPerSecond());
				signals.RhythmAVM = rhythm.getAVM();

				if (rhythmData == null)
				{
					return 8;
				}

				if ((medianData != null)
				&&  (((SCPSection3) _Default[3]).isMediansUsed()))
				{
					if (signals.RhythmAVM <= signals.MedianAVM)
					{
						ECGTool.ChangeMultiplier(medianData, signals.MedianAVM, signals.RhythmAVM);
						signals.MedianAVM = signals.RhythmAVM;
					}
					else
					{
						ECGTool.ChangeMultiplier(rhythmData, signals.RhythmAVM, signals.MedianAVM);
						signals.RhythmAVM = signals.MedianAVM;
					}

					signals.RhythmSamplesPerSecond = signals.MedianSamplesPerSecond;

					((SCPSection4) _Default[4]).AddMedians((SCPSection3) _Default[3], rhythmData, medianData);
				}
				else
				{
					signals.RhythmAVM = rhythm.getAVM();
					signals.RhythmSamplesPerSecond = rhythm.getSamplesPerSecond();
				}

				for (int loper=0;loper < signals.NrLeads;loper++)
				{
					signals[loper].Rhythm = rhythmData[loper];
				}

				return 0;
			}
			return 1;
		}
		public int setSignals(Signals signals)
		{
			if ((signals != null)
			&&  (signals.NrLeads > 0))
			{
				// Decide wich encoding to use.
				switch (_EncodingType)
				{
					case EncodingType.None:
						((SCPSection2)_Default[2]).UseNoHuffman();
					break;
					case EncodingType.OptimizedHuffman:
						// not implemented!
						((SCPSection2)_Default[2]).UseStandard();
					break;
					case EncodingType.DefaultHuffman:
					default:
						((SCPSection2)_Default[2]).UseStandard();
					break;
				}

				if (((ISignal)_Default[3]).setSignals(signals) != 0)
				{
					return 2;
				}

				SCPSection5 median = (SCPSection5) _Default[5];
				median.setAVM(signals.MedianAVM);
				median.setSamplesPerSecond(signals.MedianSamplesPerSecond);

				SCPSection6 rhythm = (SCPSection6) _Default[6];
				rhythm.setAVM(signals.RhythmAVM);
				rhythm.setSamplesPerSecond(signals.RhythmSamplesPerSecond);

				short[][] rhythmData = new short[signals.NrLeads][];
				short[][] medianData = new short[signals.NrLeads][];
				for (int loper=0;loper < signals.NrLeads;loper++)
				{
					if (signals[loper].Rhythm == null)
					{
						return 4;
					}
					rhythmData[loper] = signals[loper].Rhythm;
					if ((medianData == null)
					||  (signals[loper].Median == null))
					{
						medianData = null;
					}
					else
					{
						medianData[loper] = signals[loper].Median;
					}
				}

				if (medianData != null)
				{
					if (((ISignal)_Default[4]).setSignals(signals) != 0)
					{
						return 8;
					}

					if (signals.MedianSamplesPerSecond < signals.RhythmSamplesPerSecond )
					{
						median.setSamplesPerSecond(signals.RhythmSamplesPerSecond);
						ECGTool.ResampleSignal(medianData, signals.MedianSamplesPerSecond, signals.RhythmSamplesPerSecond, out medianData);
					}

					if (median.EncodeData(medianData, (SCPSection2) _Default[2], (ushort)((signals.MedianLength * signals.MedianSamplesPerSecond) / 1000), (_EncodingType == EncodingType.None ? (byte)0 : _DifferenceDataSection5Used)) != 0)
					{
						return 16;
					}

					if (signals.QRSZone != null)
					{
						if (signals.RhythmAVM <= signals.MedianAVM)
						{
							ECGTool.ChangeMultiplier(medianData, signals.MedianAVM, signals.RhythmAVM);
						}
						else
						{
							ECGTool.ChangeMultiplier(rhythmData, signals.RhythmAVM, signals.MedianAVM);
							rhythm.setAVM(signals.MedianAVM);
						}
					}

					ECGTool.ResampleSignal(rhythmData, signals.RhythmSamplesPerSecond, median.getSamplesPerSecond(), out rhythmData);

					if (_QRSSubtractionSupport
					&&	(signals.QRSZone != null))
					{
						((SCPSection3) _Default[3]).setMediansUsed(true);
						((SCPSection4) _Default[4]).SubtractMedians((SCPSection3) _Default[3], rhythmData, medianData);
					}
				}

				if (_BimodalCompressionUsed
				&&	(_BimodalCompressionRate > 0)
				&&	(medianData != null)
				&&	(signals.QRSZone != null))
				{
					// Bimodal Compression must be set in set section 6.
					rhythm.setBimodal(true);
					rhythm.setSamplesPerSecond(signals.MedianSamplesPerSecond / _BimodalCompressionRate);

					// Determine QRS zones for bimodal compression
					GlobalMeasurements global;
					((IGlobalMeasurement)_Default[7]).getGlobalMeasurements(out global);	
					((SCPSection4)_Default[4]).setProtected(global, median.getSamplesPerSecond(), _BimodalCompressionRate, ((SCPSection3)_Default[3]).getMinBegin(), ((SCPSection3)_Default[3]).getMaxEnd());
				}

				if (rhythm.EncodeData(rhythmData, (SCPSection2) _Default[2], (SCPSection3) _Default[3], (SCPSection4) _Default[4], signals.MedianSamplesPerSecond, (_EncodingType == EncodingType.None ? (byte)0 : _DifferenceDataSection6Used)) != 0)
				{
					return 32;
				}
				return 0;
			}
			return 1;
		}
		#endregion
		/// <summary>
		/// Function to check SCP.
		/// </summary>
		/// <param name="buffer">byte array to do check in</param>
		/// <param name="offset">position to start checking</param>
		/// <param name="crc">value crc should be</param>
		/// <param name="length">length of section</param>
		/// <returns>0 on success</returns>
		public bool CheckSCP(byte[] buffer, int offset, ushort crc, int length)
		{
			CRCTool crctool = new CRCTool();
			crctool.Init(CRCTool.CRCCode.CRC_CCITT);
			if (crctool.CalcCRCITT(buffer, offset + Marshal.SizeOf(_CRC), length - Marshal.SizeOf(_CRC)) == crc)
			{
				return true;
			}
			return false;
		}
		/// <summary>
		/// Function to set pointers.
		/// </summary>
		public void setPointers()
		{
			if (_Default[0] is SCPSection0)
			{
				SCPSection0 pointers = (SCPSection0) _Default[0];
				pointers.setNrPointers(_MinNrSections + (_Manufactor != null ? _Manufactor.Length : 0));
				int sum = Marshal.SizeOf(_CRC) + Marshal.SizeOf(_Length) + 1;
				for (int loper=0;loper < _MinNrSections;loper++)
				{
					ushort id = (ushort) loper;
					int length = _Default[loper].getLength();
					int index = (length > SCPSection.Size ? sum : 0);
					pointers.setPointer(loper, id, length, index);
					sum += length;
				}
				if (_Manufactor != null)
				{
					for (int loper=0;loper < _Manufactor.Length;loper++)
					{
						ushort id = _Manufactor[loper].getSectionID();
						int length = _Manufactor[loper].getLength();
						int index = (length > SCPSection.Size ? sum : 0);
						pointers.setPointer(_MinNrSections + loper, id, length, index);
						sum += length;
					}
				}

				_Length = sum - 1;

				// Determine file Protocol Compatibility Level.
				if (_Default[0].Works()
				&&  _Default[1].Works()
				&&  (_Default[1] is SCPSection1))
				{
					if (_Default[2].Works()
					&&  _Default[3].Works())
					{
						if (_Default[4].Works()
						&&  _Default[5].Works()
						&&  _Default[6].Works())
						{
							((SCPSection1)_Default[1]).setProtocolCompatibilityLevel(SCPSection1.ProtocolCompatibility.CatIV);
						}
						else if (_Default[5].Works())
						{
							((SCPSection1)_Default[1]).setProtocolCompatibilityLevel(SCPSection1.ProtocolCompatibility.CatIII);
						}
						else if (_Default[6].Works())
						{
							((SCPSection1)_Default[1]).setProtocolCompatibilityLevel(SCPSection1.ProtocolCompatibility.CatII);
						}
						else if (_Default[7].Works()
							&&   _Default[8].Works())
						{
							((SCPSection1)_Default[1]).setProtocolCompatibilityLevel(SCPSection1.ProtocolCompatibility.CatI);
						}
					}
					else if (_Default[7].Works()
						&&   _Default[8].Works())
					{
						((SCPSection1)_Default[1]).setProtocolCompatibilityLevel(SCPSection1.ProtocolCompatibility.CatI);
					}
				}
			}
		}
		/// <summary>
		/// Function to empty entire format.
		/// </summary>
		private void EmptyFormat()
		{
			for (int loper=0;loper < _MinNrSections;loper++)
			{
				_Default[loper].Empty();
			}
			_Manufactor = null;
		}
		#region IDisposable Members
		public override void Dispose()
		{
			base.Dispose();

			_CRC = 0;
			_Length = 0;
			if (_Default != null)
			{
				for (int loper=0;loper < _Default.Length;loper++)
				{
					if (_Default[loper] != null)
					{
						_Default[loper].Empty();
						_Default[loper] = null;
					}
				}
				_Default = null;
			}
			if (_Manufactor != null)
			{
				for (int loper=0;loper < _Manufactor.Length;loper++)
				{
					if (_Manufactor[loper] != null)
					{
						_Manufactor[loper].Empty();
						_Manufactor[loper] = null;
					}
				}
				_Manufactor = null;
			}
		}
		#endregion
		/// <summary>
		/// Function to convert to SCP.
		/// </summary>
		/// <param name="src">an ECG file to convert</param>
		/// <param name="dst">SCP file returned</param>
		/// <returns>0 on success</returns>
		public static int ToSCP(IECGFormat src, ECGConfig cfg, out IECGFormat dst)
		{
			dst = null;
			if (src != null)
			{
				dst = new SCPFormat();

				if ((cfg != null)
				&&	((dst.Config == null)
				||	 !dst.Config.Set(cfg)))
					return 1;

				int err = ECGConverter.Convert(src, dst);
				if (err != 0)
				{
					return err;
				}

				((SCPFormat)dst).setPointers();

				return 0;
			}
			return 1;
		}
		/// <summary>
		/// Enumration to set encoding used during encoding of signal.
		/// </summary>
		/// <remarks>
		/// OptimizedHuffman is same as DefaultHuffman, because it isn't implemented
		/// </remarks>
		public enum EncodingType
		{None = 0, DefaultHuffman, OptimizedHuffman}
	}
}