rawecgheader.cs

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

			if ((val != 0)
			&&	(def != HeightDefinition.Unspecified))
			{
				switch (def)
				{
					case HeightDefinition.Centimeters:
						_IdRecInfo.Height = (short) val;
						break;
					case HeightDefinition.Millimeters:
						_IdRecInfo.Height = (short) (val / 10);
						break;
					case HeightDefinition.Inches:
						_IdRecInfo.Height = (short) ((val * 254) / 100);
						break;
				}
				return 0;
			}
			return 1;
		}
		public int getPatientWeight(out ushort val, out WeightDefinition def)
		{
			val = 0;
			def = WeightDefinition.Unspecified;
			if (_IdRecInfo.Height != 0)
			{
				val = (ushort) _IdRecInfo.Height;
				def = WeightDefinition.Kilogram;
				return 0;
			}
			return 1;
		}
		public int setPatientWeight(ushort val, WeightDefinition def)
		{
			if ((val != 0)
			&&	(def != WeightDefinition.Unspecified))
			{
				switch (def)
				{
					case WeightDefinition.Kilogram:
						_IdRecInfo.Height = (short) val;
						break;
					case WeightDefinition.Gram:
						_IdRecInfo.Height = (short) (val / 1000);
						break;
					case WeightDefinition.Ounce:
						_IdRecInfo.Height = (short) ((val * 10000) / 283);
						break;
					case WeightDefinition.Pound:
						_IdRecInfo.Height = (short) ((val * 10000) / 4536);
						break;

				}
				return 0;
			}
			return 1;
		}
		public Sex Gender
		{
			get
			{
				switch ((char) _PatId.Sex)
				{
					case 'F':
						return Sex.Female;
					case 'M':
						return Sex.Male;
				}
				return Sex.Null;
			}
			set
			{
				switch (value)
				{
					case Sex.Female:
						_PatId.Sex = (byte) 'F';
						break;
					case Sex.Male:
						_PatId.Sex = (byte) 'M';
						break;
					default:
						_PatId.Sex = 0;
						break;
				}
			}
		}
		public Race PatientRace
		{
			get
			{
				switch ((char) _PatId.Race)
				{
					case 'C':
						return Race.Caucasian;
					case 'M':
						return Race.Oriental;
					case 'N':
						return Race.Black;
				}
				return Race.Null;
			}
			set
			{
				switch(value)
				{
					case Race.Caucasian:
						_PatId.Race = (byte) 'C';
						break;
					case Race.Oriental:
						_PatId.Race = (byte) 'M';
						break;
					case Race.Black:
						_PatId.Race = (byte) 'N';
						break;
					default:
						_PatId.Race = 0;
						break;
				}
			}
		}
		public AcquiringDeviceID AcqMachineID
		{
			get
			{
				AcquiringDeviceID ret = new AcquiringDeviceID(true);
				ret.DeviceCapabilities = 0x88;
				return ret;
			}
			set
			{
				if (value != null)
				{
					BytesTool.writeString(value.DeviceID.ToString("d5"), _RecInfo.CartId, 0, RawECGRecordInfo.MaxCartIdLen);
					BytesTool.writeString("ErasmusMC", _RecInfo.Location, 0, RawECGRecordInfo.MaxLocationLen);
					BytesTool.writeString(((DeviceManufactor)value.ManufactorID).ToString(), _RecInfo.Site, 0, RawECGRecordInfo.MaxSiteLen);
					BytesTool.writeString("ECGConversion 2.0", _RecInfo.ProgramVersion, 0, RawECGRecordInfo.MaxProgramVersionLen);
				}
			}
		}
		public AcquiringDeviceID AnalyzingMachineID
		{
			get {return null;}
			set {}
		}
		public DateTime TimeAcquisition
		{
			get
			{
				try
				{
					return new DateTime(_Year, _Month, _Day, _Hour, _Min, _Sec);
				}
				catch {}

				return DateTime.MinValue;
			}
			set
			{
				if (value.Year > 1000)
				{
					_Year = (short) value.Year;
					_Month = (byte) value.Month;
					_Day = (byte) value.Day;
					_Hour = (byte) value.Hour;
					_Min = (byte) value.Minute;
					_Sec = (byte) value.Second;

					BytesTool.writeString(value.Year.ToString("d4"), _RecInfo.RecDate, 0, 5);
					BytesTool.writeString(value.Month.ToString("d2"), _RecInfo.RecDate, 4, 3);
					BytesTool.writeString(value.Day.ToString("d2"), _RecInfo.RecDate, 6, 3);

					BytesTool.writeString(value.Hour.ToString("d2"), _RecInfo.RecTime, 0, 3);
					BytesTool.writeString(value.Minute.ToString("d2"), _RecInfo.RecTime, 2, 3);
					BytesTool.writeString(value.Second.ToString("d2"), _RecInfo.RecTime, 4, 3);
				}
			}
		}
		public ushort BaselineFilter
		{
			get {return 0;}
			set {}
		}
		public ushort LowpassFilter
		{
			get {return 0;}
			set {}
		}
		public byte FilterBitmap
		{
			get {return 0;}
			set {}
		}
		public string[] FreeTextFields
		{
			get {return null;}
			set {}
		}
		public string SequenceNr
		{
			get
			{
				if (_RecInfo.ECGId[0] != 0)
				{
					return BytesTool.readString(_RecInfo.ECGId, 0, RawECGRecordInfo.MaxECGIdLen);
				}
				return null;
			}
			set
			{
				if (value != null)
				{
					BytesTool.writeString(value, _RecInfo.ECGId, 0, RawECGRecordInfo.MaxECGIdLen);
				}
			}
		}
		public string AcqInstitution
		{
			get {return null;}
			set {}
		}
		public string AnalyzingInstitution
		{
			get {return null;}
			set {}
		}
		public string AcqDepartment
		{
			get {return null;}
			set {}
		}
		public string AnalyzingDepartment
		{
			get {return null;}
			set {}
		}
		public string ReferringPhysician
		{
			get {return null;}
			set {}
		}
		public string OverreadingPhysician
		{
			get {return null;}
			set {}
		}
		public string TechnicianDescription
		{
			get {return null;}
			set {}
		}
		public ushort SystolicBloodPressure
		{
			get
			{
				return (ushort) _IdRecInfo.SysBP;
			}
			set
			{
				_IdRecInfo.SysBP = (short) value;
			}
		}
		public ushort DiastolicBloodPressure
		{
			get
			{
				return (ushort) _IdRecInfo.DiaBP;
			}
			set
			{
				_IdRecInfo.DiaBP = (short) value;
			}
		}
		public Drug[] Drugs
		{
			get {return null;}
			set {}
		}
		public string[] ReferralIndication
		{
			get {return null;}
			set {}
		}
		public string RoomDescription
		{
			get {return null;}
			set {}
		}
		public byte StatCode
		{
			get {return 0xff;}
			set {}
		}
        public int getSignals(out Signals signals)
        {
            signals = new Signals();
            int err = getSignalsToObj(signals);
            if (err != 0)
            {
                signals = null;
            }
            return 0;
        }
        public int getSignalsToObj(Signals signals)
        {
            if ((Works())
			&&	(signals != null))
            {
                signals.NrLeads = (byte) _ECGInfo.NrOfLeads;

                signals.RhythmAVM = (1000.0 / (double) _ECGInfo.ECGLSBPerMV);
                signals.RhythmSamplesPerSecond = _ECGInfo.ECGSampFreq;

                for (int loper=0;loper < _ECGInfo.NrOfLeads;loper++)
                {
                    signals[loper] = new Signal();
                    signals[loper].RhythmStart = 0;
                    signals[loper].RhythmEnd = (int) _ECGInfo.NrECGSamples;

                    switch (_ECGInfo.LeadConfig[loper])
                    {
                        case 0:
                            signals[loper].Type = LeadConfiguration[0];
                            break;
                        case 1:
                            signals[loper].Type = LeadConfiguration[1];
                            break;
                        case 2:
                            signals[loper].Type = LeadConfiguration[2];
                            break;
                        case 3:
                            signals[loper].Type = LeadConfiguration[3];
                            break;
                        case 4:
                            signals[loper].Type = LeadConfiguration[4];
                            break;
                        case 5:
                            signals[loper].Type = LeadConfiguration[5];
                            break;
                        case 6:
                            signals[loper].Type = LeadConfiguration[6];
                            break;
                        case 7:
                            signals[loper].Type = LeadConfiguration[7];
                            break;
                        case 8:
                            signals[loper].Type = LeadConfiguration[8];
                            break;
                        case 9:
                            signals[loper].Type = LeadConfiguration[9];
                            break;
                        case 10:
                            signals[loper].Type = LeadConfiguration[10];
                            break;
                        case 11:
                            signals[loper].Type = LeadConfiguration[11];
                            break;
                        default:
                            signals[loper].Type = LeadType.Unknown;
                            break;
                    }
                }
                return 0;
            }
            return 1;
        }
        public int setSignals(Signals signals)
        {
            if ((signals != null)
			&&	(signals.NrLeads != 0)
			&&	(signals.RhythmAVM > 0)
			&&	(signals.RhythmSamplesPerSecond > 0))
            {
                _ECGInfo.NrOfLeads = (short) RawECGFormat.NeededLeads.Length;

                _ECGInfo.ECGLSBPerMV = 400;
                _ECGInfo.ECGSampFreq = 500;

                _ECGInfo.TremorType = 0;

                for (int loper=0;loper < _ECGInfo.NrOfLeads;loper++)
                {
                    _ECGInfo.LeadConfig[loper] = (short) RawECGFormat.NeededLeads[loper];// signals[loper].Type;
                }

                int minstart = int.MaxValue;
                int maxend = int.MinValue;

                for (int loper=0;loper < signals.NrLeads;loper++)
                {
                    if (signals[loper] != null)
                    {
                        minstart = Math.Min(minstart, signals[loper].RhythmStart);
                        maxend = Math.Max(maxend, signals[loper].RhythmEnd);
                    }
                }

                if ((minstart != int.MaxValue)
				&&	(maxend != int.MinValue)
				&&	(minstart < maxend))
                {
                    _ECGInfo.NrECGSamples = (uint) (((maxend - minstart) * 500) / signals.RhythmSamplesPerSecond);
                }

                return 0;
            }
            return 1;
        }
        
        public void WriteInfo(System.IO.StreamWriter output)
        {   //Write leadinfo
            for (int loper=0;loper < _ECGInfo.NrOfLeads;loper++)
            {
                output.Write(" ");
                output.Write(((LeadType)_ECGInfo.LeadConfig[loper]).ToString());
            }
            output.Write("\n");
        }
    }
}