/*****************************************************************************

FILE:  postclas.cpp
AUTHOR:	Patrick S. Hamilton
REVISED:	5/13/2002
  ___________________________________________________________________________

postclas.cpp: Post classifier
Copywrite (C) 2002 Patrick S. Hamilton

This file is free software; you can redistribute it and/or modify it under
the terms of the GNU Library General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option) any
later version.

This software is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE.  See the GNU Library General Public License for more
details.

You should have received a copy of the GNU Library General Public License along
with this library; if not, write to the Free Software Foundation, Inc., 59
Temple Place - Suite 330, Boston, MA 02111-1307, USA.

You may contact the author by e-mail (pat@eplimited.edu) or postal mail
(Patrick Hamilton, E.P. Limited, 35 Medford St., Suite 204 Somerville,
MA 02143 USA).  For updates to this software, please visit our website
(http://www.eplimited.com).
  __________________________________________________________________________

This file contains functions for classifying beats based after the
following beat is detected.

	ResetPostClassify() -- Resets static variables used by
		PostClassify()
	PostClassify() -- classifies each beat based on six preceding
		beats and the following beat.
	CheckPostClass() --  classifys beat type based on the last
		eight post classifications of that beat.
	CheckPCRhythm() -- returns the classification of the RR interval
		for this type of beat based its previous eight RR intervals.

****************************************************************/

#include "bdac.h"
#include <wfdb/ecgcodes.h>

// External Prototypes.

double DomCompare(int newType, int domType) ;
int GetBeatTypeCount(int type) ;

// Records of post classifications.

int PostClass[MAXTYPES][8], PCInitCount = 0 ;
int PCRhythm[MAXTYPES][8] ;

/**********************************************************************
 Resets post classifications for beats.
**********************************************************************/

void ResetPostClassify()
	{
	int i, j ;
	for(i = 0; i < MAXTYPES; ++i)
		for(j = 0; j < 8; ++j)
			{
			PostClass[i][j] = 0 ;
			PCRhythm[i][j] = 0 ;
			}
	PCInitCount = 0 ;
	}

/***********************************************************************
	Classify the previous beat type and rhythm type based on this beat
	and the preceding beat.  This classifier is more sensitive
	to detecting premature beats followed by compensitory pauses.
************************************************************************/

void PostClassify(int *recentTypes, int domType, int *recentRRs, int width, double mi2,
	int rhythmClass)
	{
	static int lastRC, lastWidth ;
	static double lastMI2 ;
	int i, regCount, pvcCount, normRR ;
	double mi3 ;

	// If the preceeding and following beats are the same type,
	// they are generally regular, and reasonably close in shape
	// to the dominant type, consider them to be dominant.

	if((recentTypes[0] == recentTypes[2]) && (recentTypes[0] != domType)
		&& (recentTypes[0] != recentTypes[1]))
		{
		mi3 = DomCompare(recentTypes[0],domType) ;
		for(i = regCount = 0; i < 8; ++i)
			if(PCRhythm[recentTypes[0]][i] == NORMAL)
				++regCount ;
		if((mi3 < 2.0) && (regCount > 6))
			domType = recentTypes[0] ;
		}

	// Don't do anything until four beats have gone by.

	if(PCInitCount < 3)
		{
		++PCInitCount ;
		lastWidth = width ;
		lastMI2 = 0 ;
		lastRC = 0 ;
		return ;
		}

	if(recentTypes[1] < MAXTYPES)
		{

		// Find first NN interval.
		for(i = 2; (i < 7) && (recentTypes[i] != recentTypes[i+1]); ++i) ;
		if(i == 7) normRR = 0 ;
		else normRR = recentRRs[i] ;

		// Shift the previous beat classifications to make room for the
		// new classification.
		for(i = pvcCount = 0; i < 8; ++i)
			if(PostClass[recentTypes[1]][i] == PVC)
				++pvcCount ;

		for(i = 7; i > 0; --i)
			{
			PostClass[recentTypes[1]][i] = PostClass[recentTypes[1]][i-1] ;
			PCRhythm[recentTypes[1]][i] = PCRhythm[recentTypes[1]][i-1] ;
			}

		// If the beat is premature followed by a compensitory pause and the
		// previous and following beats are normal, post classify as
		// a PVC.

		if(((normRR-(normRR>>3)) >= recentRRs[1]) && ((recentRRs[0]-(recentRRs[0]>>3)) >= normRR)// && (lastMI2 > 3)
			&& (recentTypes[0] == domType) && (recentTypes[2] == domType)
				&& (recentTypes[1] != domType))
			PostClass[recentTypes[1]][0] = PVC ;

		// If previous two were classified as PVCs, and this is at least slightly
		// premature, classify as a PVC.

		else if(((normRR-(normRR>>4)) > recentRRs[1]) && ((normRR+(normRR>>4)) < recentRRs[0]) &&
			(((PostClass[recentTypes[1]][1] == PVC) && (PostClass[recentTypes[1]][2] == PVC)) ||
				(pvcCount >= 6) ) &&
			(recentTypes[0] == domType) && (recentTypes[2] == domType) && (recentTypes[1] != domType))
			PostClass[recentTypes[1]][0] = PVC ;

		// If the previous and following beats are the dominant beat type,
		// and this beat is significantly different from the dominant,
		// call it a PVC.

		else if((recentTypes[0] == domType) && (recentTypes[2] == domType) && (lastMI2 > 2.5))
			PostClass[recentTypes[1]][0] = PVC ;

		// Otherwise post classify this beat as UNKNOWN.

		else PostClass[recentTypes[1]][0] = UNKNOWN ;

		// If the beat is premature followed by a compensitory pause, post
		// classify the rhythm as PVC.

		if(((normRR-(normRR>>3)) > recentRRs[1]) && ((recentRRs[0]-(recentRRs[0]>>3)) > normRR))
			PCRhythm[recentTypes[1]][0] = PVC ;

		// Otherwise, post classify the rhythm as the same as the
		// regular rhythm classification.

		else PCRhythm[recentTypes[1]][0] = lastRC ;
		}

	lastWidth = width ;
	lastMI2 = mi2 ;
	lastRC = rhythmClass ;
	}


/*************************************************************************
	CheckPostClass checks to see if three of the last four or six of the
	last eight of a given beat type have been post classified as PVC.
*************************************************************************/

int CheckPostClass(int type)
	{
	int i, pvcs4 = 0, pvcs8 ;

	if(type == MAXTYPES)
		return(UNKNOWN) ;

	for(i = 0; i < 4; ++i)
		if(PostClass[type][i] == PVC)
			++pvcs4 ;
	for(pvcs8=pvcs4; i < 8; ++i)
		if(PostClass[type][i] == PVC)
			++pvcs8 ;

	if((pvcs4 >= 3) || (pvcs8 >= 6))
		return(PVC) ;
	else return(UNKNOWN) ;
	}

/****************************************************************************
	Check classification of previous beats' rhythms based on post beat
	classification.  If 7 of 8 previous beats were classified as NORMAL
	(regular) classify the beat type as NORMAL (regular).
	Call it a PVC if 2 of the last 8 were regular.
****************************************************************************/

int CheckPCRhythm(int type)
	{
	int i, normCount, n ;


	if(type == MAXTYPES)
		return(UNKNOWN) ;

	if(GetBeatTypeCount(type) < 9)
		n = GetBeatTypeCount(type)-1 ;
	else n = 8 ;

	for(i = normCount = 0; i < n; ++i)
		if(PCRhythm[type][i] == NORMAL)
			++normCount;
	if(normCount >= 7)
		return(NORMAL) ;
	if(((normCount == 0) && (n < 4)) ||
		((normCount <= 1) && (n >= 4) && (n < 7)) ||
		((normCount <= 2) && (n >= 7)))
		return(PVC) ;
	return(UNKNOWN) ;
	}