aecgformat.cs

ecg tool kit for medical image retrieval system

			if (err != 0)
			{
				signals = null;
			}
			return err;
		}

		public int getSignalsToObj(Signals signals)
		{
			if (!Works())
				return 1;

			if (Component.Count != 1)
				return 2;

			try
			{
				aECGSeries series = Component[0];

				signals.NrLeads = (byte)(series.SequenceSet.Count-1);

				signals.RhythmSamplesPerSecond = (int) (1.0 / (double) series.SequenceSet[0].Value.Increment.Value);
				signals.RhythmAVM = (double) series.SequenceSet[1].Value.Scale.Value;

				if (series.DerivedSet.Count != 0)
				{
					signals.MedianSamplesPerSecond = (int) (1.0 / (double) series.DerivedSet[0].SequenceSet[0].Value.Increment.Value);
					signals.MedianAVM = (double) series.DerivedSet[0].SequenceSet[1].Value.Scale.Value;
					signals.MedianFiducialPoint = 0;
					signals.MedianLength = (ushort) (series.DerivedSet[0].SequenceSet[1].Value.Digits.Length * ((double) Component[0].DerivedSet[0].SequenceSet[0].Value.Increment.Value * 1000));
				}

				for (int i=0;i< signals.NrLeads;i++)
				{
					signals[i] = new Signal();
					signals[i].Rhythm = (short[]) series.SequenceSet[1+i].Value.Digits.Clone();

					ECGTool.ChangeMultiplier(
						signals[i].Rhythm,
						(double) series.SequenceSet[1+i].Value.Scale.Value,
						signals.RhythmAVM);

					if (signals.MedianLength != 0)
					{
						signals[i].Median = (short[]) series.DerivedSet[0].SequenceSet[1+i].Value.Digits.Clone();

						ECGTool.ChangeMultiplier(
							signals[i].Median,
							(double) series.DerivedSet[0].SequenceSet[1+i].Value.Scale.Value,
							signals.MedianAVM);
					}

					LeadTypeVitalRefId lt = (LeadTypeVitalRefId) Enum.Parse(
						typeof(LeadTypeVitalRefId),
						series.SequenceSet[1 + i].Code.Code,
						true);

					if ((signals.MedianSamplesPerSecond != 0)
					&&	(series.SequenceSet[1 + i].Code.Code != series.DerivedSet[0].SequenceSet[1 + i].Code.Code))
						return 3;

					signals[i].Type = (LeadType) lt;
					signals[i].RhythmStart = 0;
					signals[i].RhythmEnd = signals[i].Rhythm.Length;
				}

				signals.TrimSignals(0);
			}
			catch
			{
				return 4;
			}

			return 0;
		}

		public int setSignals(Signals signals)
		{
			if ((signals == null)
			||	(signals.NrLeads == 0)
			||	(signals.RhythmAVM <= 0)
			||	(signals.RhythmSamplesPerSecond <= 0))
			{
				return 1;
			}

			Signals sigs = signals.CalculateTwelveLeads();

			if (sigs != null)
			{
				signals = sigs;
			}

			int start, end;

			signals.CalculateStartAndEnd(out start, out end);

			if ((EffectiveTime.Type == aECGTime.TimeType.Center)
			&&	(start < end)
			&&	(end > 0))
			{
				EffectiveTime.Type = aECGTime.TimeType.LowHigh;
				EffectiveTime.ValTwo = EffectiveTime.ValOne + TimeSpan.FromSeconds(((double)(end - start)) / signals.RhythmSamplesPerSecond);
			}

			Id.Root = Guid.NewGuid().ToString();

			Code.Code = "93000";
			Code.CodeSystem = "2.16.840.1.113883.6.12";
			Code.CodeSystemName="CPT-4";

			aECGSeries series = Component[0];
			aECGSeries derivedSeries = null;
			
			series.Id.Root = Guid.NewGuid().ToString();
			
			series.Code.Code = "RHYTHM";
			series.Code.CodeSystem = "2.16.840.1.113883.5.4";
			series.Code.CodeSystemName = "ActCode";
			series.Code.DisplayName = "Rhythm Waveforms";

			series.EffectiveTime.Type = EffectiveTime.Type;
			series.EffectiveTime.ValOne = EffectiveTime.ValOne;
			series.EffectiveTime.ValTwo = EffectiveTime.ValTwo;

			series.SequenceSet[0].Code.Code = "TIME_RELATIVE";
			series.SequenceSet[0].Code.CodeSystem = "2.16.840.1.113883.5.4";
			series.SequenceSet[0].Code.CodeSystemName = "ActCode";

			series.SequenceSet[0].Value.Type = "GLIST_PQ";

			series.SequenceSet[0].Value.Head.Value = 0.0;
			series.SequenceSet[0].Value.Head.Unit = "s";
			series.SequenceSet[0].Value.Increment.Value = (1.0 / signals.RhythmSamplesPerSecond);
			series.SequenceSet[0].Value.Increment.Unit = "s";

			if (signals.MedianLength != 0)
			{
				derivedSeries = series.DerivedSet[0];

				derivedSeries.Id.Root = Guid.NewGuid().ToString();

				derivedSeries.Code.Code = "REPRESENTATIVE_BEAT";
				derivedSeries.Code.CodeSystem = "2.16.840.1.113883.5.4";
				derivedSeries.Code.CodeSystemName = "ActCode";
				derivedSeries.Code.DisplayName = "Representative Beat Waveforms";

				derivedSeries.EffectiveTime.Type = series.EffectiveTime.Type;
				derivedSeries.EffectiveTime.ValOne = series.EffectiveTime.ValOne;
				derivedSeries.EffectiveTime.ValTwo = series.EffectiveTime.ValTwo;

				derivedSeries.SequenceSet[0].Code.Code = "TIME_RELATIVE";
				derivedSeries.SequenceSet[0].Code.CodeSystem = "2.16.840.1.113883.5.4";
				derivedSeries.SequenceSet[0].Code.CodeSystemName = "ActCode";

				derivedSeries.SeriesAuthor.Set(series.SeriesAuthor);

				derivedSeries.SequenceSet[0].Value.Type = "GLIST_PQ";

				derivedSeries.SequenceSet[0].Value.Head.Value = 0.0;
				derivedSeries.SequenceSet[0].Value.Head.Unit = "s";
				derivedSeries.SequenceSet[0].Value.Increment.Value = (1.0 / signals.RhythmSamplesPerSecond);
				derivedSeries.SequenceSet[0].Value.Increment.Unit = "s";
			}

			for (int i=0,j=1;i < signals.NrLeads;i++,j++)
			{
				if (!Enum.IsDefined(typeof(LeadTypeVitalRefId), ((LeadTypeVitalRefId)signals[i].Type)))
					return 2;

				series.SequenceSet[j].Code.Code = ((LeadTypeVitalRefId)signals[i].Type).ToString();
				series.SequenceSet[j].Code.CodeSystem = "2.16.840.1.113883.6.24";
				series.SequenceSet[j].Code.CodeSystemName = "MDC";

				series.SequenceSet[j].Value.Type = "SLIST_PQ";
				series.SequenceSet[j].Value.Origin.Value = 0.0;
				series.SequenceSet[j].Value.Origin.Unit = "uV";
				series.SequenceSet[j].Value.Scale.Value = signals.RhythmAVM;
				series.SequenceSet[j].Value.Scale.Unit = "uV";

				short[] tempArray = new short[end - start];

				ECGTool.CopySignal(signals[i].Rhythm, 0, tempArray, signals[i].RhythmStart - start, (signals[i].RhythmEnd - signals[i].RhythmStart));
				series.SequenceSet[j].Value.Digits = tempArray;

				if (derivedSeries != null)
				{
					derivedSeries.SequenceSet[j].Code.Code = Component[0].SequenceSet[j].Code.Code;
					derivedSeries.SequenceSet[j].Code.CodeSystem = "2.16.840.1.113883.6.24";
					derivedSeries.SequenceSet[j].Code.CodeSystemName = "MDC";

					derivedSeries.SequenceSet[j].Value.Type = "SLIST_PQ";
					derivedSeries.SequenceSet[j].Value.Origin.Value = 0.0;
					derivedSeries.SequenceSet[j].Value.Origin.Unit = "uV";
					derivedSeries.SequenceSet[j].Value.Scale.Value = signals.MedianAVM;
					derivedSeries.SequenceSet[j].Value.Scale.Unit = "uV";

					tempArray = new short[((signals.MedianLength * signals.MedianSamplesPerSecond) / 1000) + 1];

					ECGTool.CopySignal(signals[i].Median, 0, tempArray, 0, tempArray.Length);
					derivedSeries.SequenceSet[j].Value.Digits = tempArray;
				}
			}

			return 0;
		}

		#endregion

		#region IDemographic Members
		public void Init()
		{
			Empty();
		}
		public string LastName
		{
			get
			{
				return TimepointEvent.SubjectAssignment.Subject.Demographic.PersonName.family;
			}
			set
			{
				TimepointEvent.SubjectAssignment.Subject.Demographic.PersonName.family = value;
			}
		}
		public string FirstName
		{
			get
			{
				return TimepointEvent.SubjectAssignment.Subject.Demographic.PersonName.given;
			}
			set
			{
				TimepointEvent.SubjectAssignment.Subject.Demographic.PersonName.given = value;
			}
		}
		public string PatientID
		{
			get
			{
				return TimepointEvent.SubjectAssignment.Subject.Id.Extension;
			}
			set
			{
				TimepointEvent.SubjectAssignment.Subject.Id.Extension = value;
			}
		}
		public string SecondLastName
		{
			get {return null;}
			set {}
		}
		public string PrefixName
		{
			get
			{
				return TimepointEvent.SubjectAssignment.Subject.Demographic.PersonName.prefix;
			}
			set
			{
				TimepointEvent.SubjectAssignment.Subject.Demographic.PersonName.prefix = value;
			}
		}
		public string SuffixName
		{
			get
			{
				return TimepointEvent.SubjectAssignment.Subject.Demographic.PersonName.suffix;
			}
			set
			{
				TimepointEvent.SubjectAssignment.Subject.Demographic.PersonName.suffix = value;
			}
		}
		public int getPatientAge(out ushort val, out AgeDefinition def)
		{
			val = 0;
			def = AgeDefinition.Unspecified;
			return 1;
		}
		public int setPatientAge(ushort val, AgeDefinition def)
		{
			return 1;
		}
		public Date PatientBirthDate
		{
			get
			{
				try
				{
					DateTime temp = (DateTime) TimepointEvent.SubjectAssignment.Subject.Demographic.BirthTime.Value;

					if (temp.Year > 1000)
					{
						return new Date((ushort) temp.Year, (byte) temp.Month, (byte) temp.Day);
					}
				}
				catch
				{
				}
				
				return null;
			}
			set
			{
				if ((value != null)
					&&	value.isExistingDate())
				{
					TimepointEvent.SubjectAssignment.Subject.Demographic.BirthTime.Value = new DateTime(value.Year, value.Month, value.Day, 0, 0, 0, 0);
				}
			}
		}
		public int getPatientHeight(out ushort val, out HeightDefinition def)
		{
			val = 0;
			def = HeightDefinition.Unspecified;
			return 1;
		}
		public int setPatientHeight(ushort val, HeightDefinition def)
		{
			return 1;
		}
		public int getPatientWeight(out ushort val, out WeightDefinition def)
		{
			val = 0;
			def = WeightDefinition.Unspecified;
			return 1;
		}
		public int setPatientWeight(ushort val, WeightDefinition def)
		{
			return 1;
		}
		public Sex Gender
		{
			get
			{
				if (TimepointEvent.SubjectAssignment.Subject.Demographic.AdministrativeGenderCode.Works())
				{
					switch (TimepointEvent.SubjectAssignment.Subject.Demographic.AdministrativeGenderCode.Code)
					{
						case "M": case "m":
							return Sex.Male;
						case "F": case "f":
							return Sex.Female;
					}

					return Sex.Unspecified;
				}

				return Sex.Null;
			}
			set
			{
				if (value != Sex.Null)
				{
					string code = "UN";

					switch (value)
					{
						case Sex.Male:
							code = "M";
							break;
						case Sex.Female:
							code = "F";
							break;
						default:
							break;
					}

					TimepointEvent.SubjectAssignment.Subject.Demographic.AdministrativeGenderCode.Code = code;
					TimepointEvent.SubjectAssignment.Subject.Demographic.AdministrativeGenderCode.CodeSystem = "2.16.840.1.113883.5.1";
					TimepointEvent.SubjectAssignment.Subject.Demographic.AdministrativeGenderCode.CodeSystemName = "AdministrativeGender";
				}
			}
		}
		public Race PatientRace
		{
			get
			{
				if (TimepointEvent.SubjectAssignment.Subject.Demographic.RaceCode.Works())
				{
					switch (TimepointEvent.SubjectAssignment.Subject.Demographic.RaceCode.Code)
					{
						case "2028-9":
							return Race.Oriental;
						case "2054-5":
							return Race.Black;
						case "2106-3":
							return Race.Caucasian;
					}

					return Race.Unspecified;
				}

				return Race.Null;
			}
			set
			{
				if (value != Race.Null)
				{
					string sRace = null;

					switch (value)
					{
						case Race.Oriental:
							sRace = "2028-9";
							break;
						case Race.Black:
							sRace = "2054-5";
							break;
						case Race.Caucasian:
							sRace = "2106-3";
							break;
						default:
							TimepointEvent.SubjectAssignment.Subject.Demographic.RaceCode.Code = null;
							TimepointEvent.SubjectAssignment.Subject.Demographic.RaceCode.CodeSystem = null;
							TimepointEvent.SubjectAssignment.Subject.Demographic.RaceCode.CodeSystemName = null;
							TimepointEvent.SubjectAssignment.Subject.Demographic.RaceCode.DisplayName = null;
							return;
					}

					TimepointEvent.SubjectAssignment.Subject.Demographic.RaceCode.Code = sRace;
					TimepointEvent.SubjectAssignment.Subject.Demographic.RaceCode.CodeSystem = "2.16.840.1.113883.5.104";
					TimepointEvent.SubjectAssignment.Subject.Demographic.RaceCode.CodeSystemName = "Race";
				}
			}
		}
		public AcquiringDeviceID AcqMachineID
		{
			get
			{
				if (Component.Count != 0)
				{
					AcquiringDeviceID id = new AcquiringDeviceID(true);

					Communication.IO.Tools.BytesTool.writeString(this.Component[0].SeriesAuthor.Device.manufacturerModelName, id.ModelDescription, 0, id.ModelDescription.Length);

					try
					{
						id.ManufactorID = (byte) ((DeviceManufactor) Enum.Parse(typeof(DeviceManufactor), this.Component[0].SeriesAuthor.Organization.name, true));
					}
					catch {}

					byte map = FilterBitmap;

					if (map != 0xff)
					{
						if ((map & 0x1) == 0x1)
							id.ACFrequencyEnvironment = 2;
						else if ((map & 0x2) == 0x2)
							id.ACFrequencyEnvironment = 1;
						else
							id.ACFrequencyEnvironment = 0;
					}

					return id;
				}

				return null;
			}
			set
			{
				if (value != null)
				{
					this.Component[0].SeriesAuthor.Device.Id.Extension = "0";
					this.Component[0].SeriesAuthor.Device.Code.Code = "12LEAD_ELECTROCARDIOGRAPH";
					this.Component[0].SeriesAuthor.Device.Code.CodeSystem = "";
				
					this.Component[0].SeriesAuthor.Device.manufacturerModelName = Communication.IO.Tools.BytesTool.readString(value.ModelDescription, 0, value.ModelDescription.Length);
					this.Component[0].SeriesAuthor.Device.softwareName = typeof(ECGConversion.ECGConverter).Namespace;

					this.Component[0].SeriesAuthor.Organization.name =  ((DeviceManufactor)value.ManufactorID).ToString();
				}
			}
		}
		public AcquiringDeviceID AnalyzingMachineID
		{
			get {return null;}
			set {}
		}
		public DateTime TimeAcquisition
		{
			get
			{
				if (EffectiveTime.Works())
				{
					return EffectiveTime.ValOne;
				}
			
				return DateTime.MinValue;
			}
			set
			{
				EffectiveTime.Type = aECGTime.TimeType.Center;
				EffectiveTime.ValOne = value;
			}
		}
		public ushort BaselineFilter