pdfformat.cs

ecg tool kit for medical image retrieval system

/***************************************************************************
Copyright 2008, 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.Collections;
using System.Drawing;
using System.IO;
using System.Text;

using ECGConversion.ECGDiagnostic;
using ECGConversion.ECGGlobalMeasurements;
using ECGConversion.ECGSignals;

using iTextSharp.text;
using iTextSharp.text.pdf;

namespace ECGConversion.PDF
{
	/// <summary>
	/// Class containing the PDF format.
	/// </summary>
	public class PDFFormat : IECGFormat, ISignal, IGlobalMeasurement, IDiagnostic
	{
		public enum SupportedPaper
		{
			A4,
			LETTER
		}

		private PDFDemographics _Demographics;
		private Signals _Signals;
		private GlobalMeasurements _GlobalMeasurements;
		private Statements _Diagnostic;

		private float _Gain
		{
			get
			{
				try
				{
					return float.Parse(_Config["Gain"], System.Globalization.CultureInfo.CurrentUICulture);
				}
				catch {}

				return 10f;
			}
		}

		private ECGDraw.ECGDrawType _DrawType
		{
			get
			{
				try
				{
					return (ECGDraw.ECGDrawType) Enum.Parse(typeof(ECGDraw.ECGDrawType), _Config["Lead Format"], true);
				}
				catch {}

				return ECGDraw.ECGDrawType.None;
			}
		}

		private SupportedPaper _PaperType
		{
			get
			{
				try
				{
					return (SupportedPaper) Enum.Parse(typeof(SupportedPaper), _Config["Paper Type"], true);
				}
				catch {}

				return SupportedPaper.A4;
			}
		}

		private iTextSharp.text.Rectangle _PageSize
		{
			get
			{
				iTextSharp.text.Rectangle ret = PageSize.A4;

				switch (_PaperType)
				{
					case SupportedPaper.LETTER:	
						ret = PageSize.LETTER;
						break;
					default:
						break;
				}

				return ret;
			}
		}

		private int _SignalLength
		{
			get
			{
				if (_Signals != null)
				{
					int start, end;

					_Signals.CalculateStartAndEnd(out start, out end);

					return (int) Math.Round((end - start) / (float)_Signals.RhythmSamplesPerSecond);
				}

				return 0;
			}
		}

		private string _DocumentTitle
		{
			get
			{
				string temp = _Config["Document Title"];

				if (temp == null)
					temp = "ECG - " + _Demographics.PatientID + " - " + _Demographics.TimeAcquisition.ToString();

				return temp;
			}
		}

		private string _DocumentCreator
		{
			get
			{
				string temp = _Config["Document Creator"];

				if (temp == null)
					temp = "ECGConversion Toolkit";

				return temp;
			}
		}

		private string _DocumentAuthor
		{
			get
			{
				string temp = _Config["Document Author"];

				if (temp == null)
					temp = "ECGConversion Toolkit";

				return temp;
			}
		}

		public PDFFormat()
		{
			string[]
				must = new string[]{"Lead Format", "Paper Type", "Gain"},
				poss = new string[]{"Document Title", "Document Creator", "Document Author"};

			_Config = new ECGConfig(must, poss, new ECGConfig.CheckConfigFunction(this._ConfigurationWorks));
			
			_Config["Lead Format"] = ECGDraw.ECGDrawType.Regular.ToString();
			_Config["Paper Type"] = "A4";
			_Config["Gain"] = "10";

			Empty();
		}

		private bool _ConfigurationWorks()
		{
			try
			{
				Enum.Parse(typeof(ECGDraw.ECGDrawType), _Config["Lead Format"], true);
				float.Parse(_Config["Gain"], System.Globalization.CultureInfo.CurrentUICulture);
				Enum.Parse(typeof(SupportedPaper), _Config["Paper Type"], true);

				return true;
			}
			catch {}

			return false;
		}

		#region IECGFormat Members
		public override int Read(Stream input, int offset)
		{
			return 0x1;
		}
		public override int Read(string file, int offset)
		{
			return 0x1;
		}
		public override int Read(byte[] buffer, int offset)
		{
			return 0x1;
		}
		public override int Write(string file)
		{
			if (file != null)
			{
				Stream output = null;
					
				try
				{
					// open stream to write to.
					output = new FileStream(file, FileMode.Create);

					// use write function for streams.
					return Write(output);
				}
				catch {}
				finally
				{
					if (output != null)
						output.Close();
				}
			}
			return 0x1;
		}
		public override int Write(Stream output)
		{
			if ((output != null)
			&&  (output.CanWrite)
			&&	Works())
			{
				Signals sigs = _Signals.CalculateTwelveLeads();

				bool bTwelveLeadECG =  sigs != null;

				if (sigs == null)
					sigs = _Signals;

				if ((_DrawType & ECGDraw.PossibleDrawTypes(sigs)) != 0)
				{
					int sigLength = _SignalLength;

					bool bRotated = sigs.IsTwelveLeads
								&&	((_DrawType != ECGDraw.ECGDrawType.Regular)
								||	 (sigLength == 9)
								||	 (sigLength == 10));

					Document document = new Document(bRotated ? _PageSize.Rotate() : _PageSize);
					
					float
						width = (float) Math.Round((document.PageSize.Width * PDFTool.mm_Per_Inch) / PDFTool.PdfDocumentDpi),
						height = (float) Math.Round((document.PageSize.Height * PDFTool.mm_Per_Inch) / PDFTool.PdfDocumentDpi);

					try
					{
						PdfWriter writer = PdfWriter.GetInstance(document, output);

						document.AddTitle(_DocumentTitle);
						document.AddCreator(_DocumentCreator);
						document.AddAuthor(_DocumentAuthor);

						document.Open();

						PdfContentByte cb = writer.DirectContent;

						cb.Transform(new System.Drawing.Drawing2D.Matrix(1, 0, 0, 1, 0, writer.PageSize.Height));

						cb.SetFontAndSize(BaseFont.CreateFont(BaseFont.COURIER, BaseFont.CP1252, false), 8.0f);

						if (bRotated)
						{
							RectangleF gridRect = PDFTool.CreateRectangle(width, height, 260.0f, 160.0f, 165.0f);

							cb.SetLineWidth(0.5f);
							cb.SetRGBColorStroke(0, 0, 0);

							DrawPageHeader(cb, new RectangleF(gridRect.X, 5.0f, gridRect.Width, gridRect.Y - 5.0f), 3.5f);

							cb.SetLineWidth(0.25f);
							cb.SetRGBColorStroke(0xf9, 0xcb, 0xcb);

							PDFTool.DrawGrid(cb, 1.0f, gridRect);

							cb.SetLineWidth(0.5f);
							cb.SetRGBColorStroke(0xf9, 0xba, 0xba);

							PDFTool.DrawGrid(cb, 5.0f, gridRect);

							PointF point = new PointF(gridRect.X, gridRect.Y);

							cb.SetLineWidth(0.5f);
							cb.SetRGBColorStroke(0, 0, 0);

							PDFTool.DrawGridHeader(cb, gridRect, 25.0f, _Gain);

							switch (_DrawType)
							{
								case ECGDraw.ECGDrawType.Regular:
								{
									point.Y += 15.0f;

									for (int i=0;i < 12;i++)
									{
										int nrSamples = 0;

										nrSamples = PDFTool.DrawSignal(cb, point, gridRect.Width, 25.0f, _Gain, sigs, i, nrSamples, 10.0f, true);

										point.Y += 12.5f;
									}
								}
								break;
								case ECGDraw.ECGDrawType.ThreeXFour:
								{
									point.Y += 25.0f;

									PointF
										point2 = new PointF(point.X +  72.5f, point.Y),
										point3 = new PointF(point.X + 135.0f, point.Y),
										point4 = new PointF(point.X + 197.5f, point.Y);

									for (int i=0;i < 3;i++)
									{
										int nrSample = 0;

										nrSample = PDFTool.DrawSignal(cb, point, (point2.X - point.X), 25.0f, _Gain, sigs, i, nrSample, 10.0f, true);
										nrSample = PDFTool.DrawSignal(cb, point2, (point3.X - point2.X), 25.0f, _Gain, sigs, i + 3, nrSample, 0, true);
										nrSample = PDFTool.DrawSignal(cb, point3, (point4.X - point3.X), 25.0f, _Gain, sigs, i + 6, nrSample, 0, true);
										nrSample = PDFTool.DrawSignal(cb, point4, gridRect.Width - (point4.X - gridRect.X), 25.0f, _Gain, sigs, i + 9, nrSample, 0, true);

										point.Y += 55.0f;
										point2.Y += 55.0f;
										point3.Y += 55.0f;
										point4.Y += 55.0f;
									}
								}
								break;
								case ECGDraw.ECGDrawType.ThreeXFourPlusOne:
								{
									point.Y += 20.0f;

									PointF
										point2 = new PointF(point.X +  72.5f, point.Y),
										point3 = new PointF(point.X + 135.0f, point.Y),
										point4 = new PointF(point.X + 197.5f, point.Y);

									for (int i=0;i < 3;i++)
									{
										int nrSample = 0;

										nrSample = PDFTool.DrawSignal(cb, point, (point2.X - point.X), 25.0f, _Gain, sigs, i, nrSample, 10.0f, true);
										nrSample = PDFTool.DrawSignal(cb, point2, (point3.X - point2.X), 25.0f, _Gain, sigs, i + 3, nrSample, 0, true);
										nrSample = PDFTool.DrawSignal(cb, point3, (point4.X - point3.X), 25.0f, _Gain, sigs, i + 6, nrSample, 0, true);
										nrSample = PDFTool.DrawSignal(cb, point4, gridRect.Width - (point4.X - gridRect.X), 25.0f, _Gain, sigs, i + 9, nrSample, 0, true);

										point.Y += 40.0f;
										point2.Y += 40.0f;
										point3.Y += 40.0f;
										point4.Y += 40.0f;
									}

									PDFTool.DrawSignal(cb, point, gridRect.Width, 25.0f, _Gain, sigs, 1, 0, 10.0f, true);
								}
								break;
								case ECGDraw.ECGDrawType.ThreeXFourPlusThree:
								{
									point.Y += 12.5f;

									PointF
										point2 = new PointF(point.X +  72.5f, point.Y),
										point3 = new PointF(point.X + 135.0f, point.Y),
										point4 = new PointF(point.X + 197.5f, point.Y);

									for (int i=0;i < 3;i++)
									{
										int nrSample = 0;

										nrSample = PDFTool.DrawSignal(cb, point, (point2.X - point.X), 25.0f, _Gain, sigs, i, nrSample, 10.0f, true);
										nrSample = PDFTool.DrawSignal(cb, point2, (point3.X - point2.X), 25.0f, _Gain, sigs, i + 3, nrSample, 0, true);
										nrSample = PDFTool.DrawSignal(cb, point3, (point4.X - point3.X), 25.0f, _Gain, sigs, i + 6, nrSample, 0, true);
										nrSample = PDFTool.DrawSignal(cb, point4, gridRect.Width - (point4.X - gridRect.X), 25.0f, _Gain, sigs, i + 9, nrSample, 0, true);

										point.Y += 27.5f;
										point2.Y += 27.5f;
										point3.Y += 27.5f;
										point4.Y += 27.5f;
									}

									PDFTool.DrawSignal(cb, point, gridRect.Width, 25.0f, _Gain, sigs, 1, 0, 10.0f, true);
									point.Y += 25.0f;
									PDFTool.DrawSignal(cb, point, gridRect.Width, 25.0f, _Gain, sigs, 7, 0, 10.0f, true);
									point.Y += 27.5f;
									PDFTool.DrawSignal(cb, point, gridRect.Width, 25.0f, _Gain, sigs, 10, 0, 10.0f, true);
								}
								break;
								case ECGDraw.ECGDrawType.SixXTwo:
								{
									point.Y += 12.5f;

									PointF point2 = new PointF(point.X + (gridRect.Width / 2.0f) + 5.0f, point.Y);

									for (int i=0;i < 6;i++)
									{
										int nrSample = 0;

										nrSample = PDFTool.DrawSignal(cb, point, (point2.X - point.X), 25.0f, _Gain, sigs, i, nrSample, 10.0f, true);
										nrSample = PDFTool.DrawSignal(cb, point2, gridRect.Width - (point2.X - gridRect.X), 25.0f, _Gain, sigs, i + 6, nrSample, 0, true);

										point.Y += 27.5f;
										point2.Y += 27.5f;
									}

								}
								break;
								case ECGDraw.ECGDrawType.Median:
								{
									point.X += 20.0f;
									point.Y += 25.0f;

									PointF
										point2 = new PointF(point.X +  65f, point.Y),
										point3 = new PointF(point.X + 130f, point.Y),
										point4 = new PointF(point.X + 195f, point.Y);

									for (int i=-1;i > -4;i--)
									{
										point.X -= 20.0f;

										PDFTool.DrawCalibrationPulse(cb, point, 10.0f, _Gain);

										point.X += 20.0f;

										PDFTool.DrawSignal(cb, point, (point2.X - point.X), 25.0f, _Gain, sigs, i, 0, 0, true);
										PDFTool.DrawSignal(cb, point2, (point3.X - point2.X), 25.0f, _Gain, sigs, i - 3, 0, 0, true);
										PDFTool.DrawSignal(cb, point3, (point4.X - point3.X), 25.0f, _Gain, sigs, i - 6, 0, 0, true);
										PDFTool.DrawSignal(cb, point4, gridRect.Width - (point4.X - gridRect.X), 25.0f, _Gain, sigs, i - 9, 0, 0, true);

										point.Y += 55.0f;
										point2.Y += 55.0f;
										point3.Y += 55.0f;
										point4.Y += 55.0f;
									}
								}
								break;
								default:
									return 2;
							}
						}
						else if ((sigLength <= 8)
							&&	 sigs.IsTwelveLeads)
						{
							RectangleF gridRect = (_PaperType == SupportedPaper.LETTER) ? PDFTool.CreateRectangle(width, height, 200.0f, (15.0f * sigs.NrLeads) + 20.0f, 230.0f) : PDFTool.CreateRectangle(width, height, 200.0f, (20.0f * sigs.NrLeads) + 15.0f, 257.5f); 

							cb.SetLineWidth(0.5f);
							cb.SetRGBColorStroke(0, 0, 0);

							DrawPageHeader(cb, new RectangleF(gridRect.X, 5.0f, gridRect.Width, gridRect.Y - 5.0f), 3.5f);

							cb.SetLineWidth(0.25f);
							cb.SetRGBColorStroke(0xf9, 0xcb, 0xcb);

							PDFTool.DrawGrid(cb, 1.0f, gridRect);

							cb.SetLineWidth(0.5f);
							cb.SetRGBColorStroke(0xf9, 0xba, 0xba);

							PDFTool.DrawGrid(cb, 5.0f, gridRect);

							PointF point = new PointF(gridRect.X, gridRect.Y + 15.0f);

							cb.SetLineWidth(0.5f);
							cb.SetRGBColorStroke(0, 0, 0);

							PDFTool.DrawGridHeader(cb, gridRect, 25.0f, _Gain);

							for (int i=0;i < sigs.NrLeads;i++)
							{
								PDFTool.DrawSignal(cb, point, gridRect.Width, 25.0f, _Gain, sigs, i, 0, 0.0f, false);

								point.Y += (_PaperType == SupportedPaper.LETTER) ? 15.0f : 20.0f ;
							}

							point.X = gridRect.X + 5.0f;
							point.Y = gridRect.Bottom;

							PDFTool.DrawCalibrationPulse(cb, point, 10.0f, _Gain);
						}
						else
						{
							int start, end, prev = -1;
							bool bFirst = true;

							sigs.CalculateStartAndEnd(out start, out end);

							if (start > 0)
								end -= start;
							start = 0; end--;

							RectangleF gridRect = new RectangleF(0, 0, width, height);

							DateTime dtStart = _Demographics.TimeAcquisition;