using System;
using HalconDotNet;

namespace HalconTools
{
	/// <summary>
	/// To determine the performance of a shape-based model, given
	/// a parameter setup for model creation and detection, 
	/// this class applies a model detection for the whole set
	/// of test images loaded and computes an all-over statistics.
	/// </summary>
    public class MatchingOptStatistics: MatchingOpt
	{
		// recognize - group 
		private	int 	mMatchesNumProb;
		private	bool	mModelFound;
		private	int		mSpecMatchesNum;
		private	int		mMaxMatchesNum;
		private	int		mFoundMatchesNum;
		private	int		mImagesWithOneMatchNum;
		private	int		mImagesWithSpecMatchesNum;
		private	int		mImagesWithMaxMatchesNum;

		// statistic - group 
		private double mScoreMin;	
		private double mScoreMax;
		private double mTimeMin;	
		private double mTimeMax;	
		private double mRowMin;		
		private double mRowMax;
		private double mColMin;		
		private double mColMax;
		private double mAngleMin;	
		private double mAngleMax;
		private double mScaleRowMin;
		private double mScaleRowMax;
		private double mScaleColMin;
		private double mScaleColMax;
	

        /// <summary>Constructor</summary>
        /// <param name="mAss">MatchingAssistant that created this instance</param>
        /// <param name="mPars">Current set of matching parameters</param>
		public MatchingOptStatistics(MatchingAssistant mAss, MatchingParam mPars)
		{
			mAssistant	= mAss;
			mParams		= mPars;
			NotifyStatisticsObserver = new StatisticsDelegate(dummy);	

			reset();
			tImageCount	= mAssistant.TestImages.Count;
		}

        /// <summary>
        /// With each execution step the shape-based model is searched in
        /// the current test image. The detection result is then compared 
        /// with the previous results and the overall statistics is adjusted.
        /// </summary>
		public override bool ExecuteStep()
		{	
			string fileName, imgNumStr;
			int val, i;
			string matchFormatStr;  
			int actualMatches;		
			int expectedMatches;	
			int maxNumMatches;		
			double score, time, row, col, angle, angleB, scaleR, scaleC;

			if(!iterator.MoveNext())
				return false;
			
			fileName = (string)iterator.Current;
			mAssistant.setTestImage(fileName);

			if(!(mOptSuccess = mAssistant.applyFindModel())) 
				return false;
			
			mResults	    = mAssistant.getMatchingResults();
			actualMatches   = mResults.count;

			// determine recognition rate ------------------ 
			expectedMatches = mParams.mRecogManualSel;
			maxNumMatches	= mParams.mNumMatches;
			
			mSpecMatchesNum	 += expectedMatches;
			mMaxMatchesNum   += maxNumMatches;
			mFoundMatchesNum +=	actualMatches;

			if(actualMatches > 0)
				mImagesWithOneMatchNum++;

			if(actualMatches >= expectedMatches)
				mImagesWithSpecMatchesNum++;

			if(actualMatches == maxNumMatches)
				mImagesWithMaxMatchesNum++;

			mCurrentIndex++;
			
			this.inspectTabRecogRateData[2] = "-";
			this.inspectTabRecogRateData[3] = "-";
			this.inspectTabRecogRateData[4] = "-";

			imgNumStr = " of " + mCurrentIndex + " images)"; 
			
			val = mImagesWithOneMatchNum;
			this.inspectTabRecogRateData[0] = Math.Round(100.0* ((double)val / mCurrentIndex), 2)  
														 + " %  ("  + val + imgNumStr;
			val = mImagesWithSpecMatchesNum;
			this.inspectTabRecogRateData[1] = Math.Round(100.0* ((double) val / mCurrentIndex), 2) 
														 + " %  ("  + val + imgNumStr;
			if(mMaxMatchesNum > 0)
			{
				matchFormatStr	=  " of " + mMaxMatchesNum + " models)";

				val = mImagesWithMaxMatchesNum;
				this.inspectTabRecogRateData[2] = Math.Round(100.0* ((double)val / mCurrentIndex), 2) 
															 + " %  (" + val + imgNumStr;
				val = mFoundMatchesNum;
				this.inspectTabRecogRateData[3] = Math.Round(100.0*((double) val / mMaxMatchesNum), 2) 
															 + " %  (" + val + matchFormatStr;
			}
			
			if(mSpecMatchesNum  > 0)
			{	
				matchFormatStr	=  " of " + mSpecMatchesNum + " models)";
				val = mFoundMatchesNum;
				this.inspectTabRecogRateData[4] = Math.Round(100.0* ((double)val / mSpecMatchesNum), 2) 
															 + " %  (" + val + matchFormatStr;
			}
			NotifyStatisticsObserver(MatchingOpt.UPDATE_INSP_RECOGRATE);

			// determine statistics data ------------ 
			if(actualMatches > 0)
			{
				i=0;
				if(!mModelFound)
				{
					mScoreMin	=	mScoreMax	= mResults.mScore[0].D;
					mTimeMin	=	mTimeMax	= mResults.mTime;
					mRowMin		=	mRowMax		= mResults.mRow[0].D;
					mColMin		=	mColMax		= mResults.mCol[0].D;
					mAngleMin	=	mAngleMax	= mResults.mAngle[0].D;
					mScaleRowMin=	mScaleRowMax= mResults.mScaleRow[0].D; 
					mScaleColMin=	mScaleColMax= mResults.mScaleCol[0].D; 
					mModelFound	=	true;
					i++;
				}
				
				for(; i < actualMatches; i++)
				{
					score	= mResults.mScore[i].D;
					if(score < mScoreMin)
						mScoreMin = score;
					else if(score > mScoreMax)
						mScoreMax = score;

					row		= mResults.mRow[i].D;
					if(row < mRowMin)
						mRowMin = row;
					else if(row > mRowMax)
						mRowMax	= row;

					col		= mResults.mCol[i].D;
					if(col < mColMin)
						mColMin = col;
					else if(col > mColMax)
						mColMax	= col;

					angle	= mResults.mAngle[i].D;
					if(angle < mAngleMin)
						mAngleMin = angle;
					else if(angle > mAngleMax)
						mAngleMax = angle;

					scaleR	= mResults.mScaleRow[i].D;
					if(scaleR < mScaleRowMin)
						mScaleRowMin = scaleR;
					else if(scaleR > mScaleRowMax)
						mScaleRowMax = scaleR;

					scaleC	= mResults.mScaleCol[i].D;
					if(scaleC < mScaleColMin)
						mScaleColMin = scaleC;
					else if(scaleC > mScaleColMax)
						mScaleColMax = scaleC;
				}//end of for

				time	= mResults.mTime;
				if(time < mTimeMin)
					mTimeMin = time;
				else if(time > mTimeMax)
					mTimeMax = time;
			}//end of if

			
			if(mModelFound)
			{	
				this.inspectTabStatisticsData[0]	= "" + Math.Round(mScoreMin, 2); 
				this.inspectTabStatisticsData[1]	= "" + Math.Round(mScoreMax, 2); 
				this.inspectTabStatisticsData[2]	= "" + Math.Round((mScoreMax - mScoreMin),2); 

				this.inspectTabStatisticsData[3]	= "" + Math.Round(mTimeMin, 2); 
				this.inspectTabStatisticsData[4]	= "" + Math.Round(mTimeMax, 2); 
				this.inspectTabStatisticsData[5]	= "" + Math.Round((mTimeMax - mTimeMin),2); 

				this.inspectTabStatisticsData[6]	= "" + Math.Round(mRowMin, 2);  
				this.inspectTabStatisticsData[7]	= "" + Math.Round(mRowMax, 2);  
				this.inspectTabStatisticsData[8]	= "" + Math.Round((mRowMax - mRowMin), 2); 

				this.inspectTabStatisticsData[9]	= "" + Math.Round(mColMin, 2);  
				this.inspectTabStatisticsData[10]	= "" + Math.Round(mColMax, 2); 
				this.inspectTabStatisticsData[11]	= "" + Math.Round((mColMax - mColMin), 2); 

				angle = (double)mAngleMin*180.0/Math.PI;
				angleB = (double)mAngleMax*180.0/Math.PI;
				this.inspectTabStatisticsData[12]	= "" + Math.Round(angle, 2);  
				this.inspectTabStatisticsData[13]	= "" + Math.Round(angleB, 2) ; 
				this.inspectTabStatisticsData[14]	= "" + Math.Round((angleB - angle), 2) ; 

				this.inspectTabStatisticsData[15]	= "" + Math.Round(mScaleRowMin, 2); 
				this.inspectTabStatisticsData[16]	= "" + Math.Round(mScaleRowMax, 2); 
				this.inspectTabStatisticsData[17]	= "" + Math.Round((mScaleRowMax - mScaleRowMin),2);  

				this.inspectTabStatisticsData[18]	= "" + Math.Round(mScaleColMin, 2);  
				this.inspectTabStatisticsData[19]	= "" + Math.Round(mScaleColMax, 2); 
				this.inspectTabStatisticsData[20]	= "" + Math.Round((mScaleColMax - mScaleColMin), 2); 

				NotifyStatisticsObserver(MatchingOpt.UPDATE_INSP_STATISTICS);
			}
			return (mCurrentIndex < tImageCount);
		}


        /// <summary>
        /// Resets all parameters for evaluating the performance to their initial values.
        /// </summary>
		public override void reset()
		{
			mMatchesNumProb		= mParams.mNumMatches;
			mModelFound			= false;
			mSpecMatchesNum		= 0;
			mMaxMatchesNum		= 0;
			mFoundMatchesNum	= 0;
			mImagesWithOneMatchNum 		= 0;
			mImagesWithSpecMatchesNum	= 0;	
			mImagesWithMaxMatchesNum	= 0;
			mOptSuccess  = false;
		
			for(int i=0; i < 21;i++)
				this.inspectTabStatisticsData[i]="-";

			inspectTabRecogRateData[0] = "100.00 % (1 of 1  image)";
			inspectTabRecogRateData[1] = "100.00 % (1 of 1  image)";
			inspectTabRecogRateData[2] = "100.00 % (1 of 1  image)";
			inspectTabRecogRateData[3] = "100.00 % (1 of 1 model)";
			inspectTabRecogRateData[4] = "100.00 % (1 of 1 model)";

			tImageCount		= mAssistant.TestImages.Count;
			iterator		= mAssistant.TestImages.Keys.GetEnumerator();
			mCurrentIndex	= 0;
		}

        /// <summary>
        /// If the optimization has stopped, then check whether it was
        /// completed successfully or whether it was aborted 
        /// due to errors or to user interaction.
        /// Depending on the failure or success of the run, the GUI is notified
        /// for visual update of the results and obtained statistics.
        /// </summary>
		public override void stop()
		{
			if(tImageCount==0)
			{
				NotifyStatisticsObserver(MatchingAssistant.ERR_NO_TESTIMAGE);
			}
			else if(!mOptSuccess)
			{
				NotifyStatisticsObserver(MatchingOpt.UPDATE_TEST_ERR);
			}
		}
	}//end of class
}//end of namespace