C# Application to Create and Recognize Mouse Gestures (.NET)

using System;
using System.Drawing;
using System.Collections;
using System.Drawing.Drawing2D;

namespace MouseGesture
{
	#region GestureRegularization abstract class
	//La classe non pu� essere instanziata e contiene i metodi che sono necessari alla regolarizzazione
	//dei punti delle gesture, e al recupero delle informazioni degli array di punti
	public abstract class GestureRegularization
	{
		#region ReduceGesturePoints static function
		//La funzione semplifica la gesture nel caso abbia un numero di punti superirore al
		//massimo cionsentito
		public static int ReduceGesturePoints(ArrayList Points)
		{
			//Calcolo i punti da rimuovere
			int ExcessivePoints=Points.Count-MainBoard.GestureMaximumPoints;

			//Ciclo per ogni punto in eccesso
			for(int i=0; i<ExcessivePoints; i++)
			{
				//Calcolo il segmento pi� piccolo dell'intera gesture, ritornando l'indice del
				//primo punto che lo compone
				int index=GestureRegularization.GetFirstIndexMinSegment(Points);
				//Aggiungo il punto medio tra i due estrmi del segmento minimo
				GestureRegularization.AddMidPoint(Points,index);
				//Rimuovo i due punti che formano gli estrmi dell'ex segmento minimo
				GestureRegularization.RemovePoint(Points,index+2);
				GestureRegularization.RemovePoint(Points,index);
			}

			//Ritorno il numero di punti rimossi
			return ExcessivePoints;
		}
		#endregion

		#region ExpandGesturePoints static function
		//La funzione si occupa di aumentare il numero dei punti della gesture, nel caso siano meno del minimo consentito
		public static int ExpandGesturePoints(ArrayList Points)
		{
			//Calcolo il numero di punti mancanti
			int GapPoints=MainBoard.GestureMaximumPoints-Points.Count;

			//Ciclo perogni punto di gap
			for(int i=0; i<GapPoints; i++)
			{
				//Calcolo il segmento pi� grande, e ritorno l'indice del primo punto
				int index=GestureRegularization.GetFirstIndexMaxSegment(Points);
				//Aggiungo un punto tra gli estremi del segmento massimo
				GestureRegularization.AddMidPoint(Points,index);
			}

			//Ritorno il numero di punti aggiunti
			return GapPoints;
		}
		#endregion

		#region GetFirstIndexMinSegment static function
		//Calcolo il segmento minimo P0-P1 del set di punti e ritorno l'indice di P0
		public static int GetFirstIndexMinSegment(ArrayList Points)
		{
			//Preparo il vettore delle lunghezza dei segmenti
			double[] Lenghts=new double[Points.Count-1];
			//Popolo il vettore con le lunghezze dei segmenti
			Lenghts=GestureRegularization.GetSegmentsLenghts(Points);
			
			//Calcolo il minimo tra i segmenti, memorizzando l'indice del primo
			//punto del segmento minimo
			int ret=0;
			for(int i=1; i<Lenghts.Length; i++)
			{
				if(Lenghts[ret]>Lenghts[i])
					ret=i;
			}

			//Ritorno il valore dell'indice come richiesto
			return ret;
		}
		#endregion

		#region GetFirstIndexMaxSegment static function
		//Calcolo il segmento massimo P0-P1 del set di punti e ritorno l'indice di P0
		public static int GetFirstIndexMaxSegment(ArrayList Points)
		{
			//Preparo il vettore delle lunghezza dei segmenti
			double[] Lenghts=new double[Points.Count-1];
			//Popolo il vettore con le lunghezze dei segmenti
			Lenghts=GestureRegularization.GetSegmentsLenghts(Points);
			
			//Calcolo il massimo tra i segmenti, memorizzando l'indice del primo
			//punto del segmento maggiore
			int ret=0;
			for(int i=1; i<Lenghts.Length; i++)
			{
				if(Lenghts[ret]<Lenghts[i])
					ret=i;
			}

			//Ritorno il valore dell'indice come richiesto
			return ret;
		}
		#endregion

		#region RemovePoint static function
		//La funzione rimuove il punto all'indice specificato, controllando se sia ilprimo o l'ultimo
		public static void RemovePoint(ArrayList Points,int Index)
		{
			if(Index==0) //Se l'indice � quello inziale, allora cancello il punto successivo
				Points.RemoveAt(1);
			else if(Index==Points.Count-1)	//Se l'indice � quello finale, allora cancello il punto precedente
				Points.RemoveAt(Points.Count-2);
			else	//Se l'indice non � il 1� o l'ultimo, cancello il punto relativo
				Points.RemoveAt(Index);
		}
		#endregion
		
		#region AddMidPoint static function
		//La funzione aggiunge un punto tra il punto specificato da index e il successivo
		public static void AddMidPoint(ArrayList Points,int Index)
		{
			//Calcolo il punto medio tra i due punti memorizzandolo nella variabile
			PointF MidPoint=GestureRegularization.GetMidPoint(((PointF)Points[Index]),((PointF)Points[Index+1]));
			//Inserisco il punto medio nella posizione successiva a quella specificata
			Points.Insert(Index+1,MidPoint);
		}
		#endregion

		#region GetSegmentsLenghts static function
		//La funzione calcola la lunghezza dei segmenti
		public static double[] GetSegmentsLenghts(ArrayList Points)
		{
			//Inizializzo il vettore delle lunghezze (ha un componente in meno rispetto alla totalit� dei punti)
			double[] vect=new double[Points.Count-1];
			//Per ogni coppia di punti calcolo la lunghezza del segmento che formano
			for(int i=0; i<Points.Count-1; i++)
				vect[i]=GestureRegularization.GetSegmentLength(((PointF)Points[i]),((PointF)Points[i+1]));

			//Ritorno il vettore delle lunghezze
			return vect;
		}
		#endregion

		#region GetSegmentLength static function
		//La funzione calcola la lunghezza del segmento tra due punti
		public static double GetSegmentLength(PointF pointA, PointF pointB)
		{
			//Calcolo il delta x al quadrato
			double DX2=(pointA.X-pointB.X)*(pointA.X-pointB.X);
			//Calcolo il delta y al quadrato
			double DY2=(pointA.Y-pointB.Y)*(pointA.Y-pointB.Y);

			//Restituisco la radice della somma dei delta al quadrato
			return Math.Sqrt(DX2+DY2);		
		}
		#endregion

		#region GetMidPoint static function
		//Calcolo il punto medio tra due punti dati
		public static PointF GetMidPoint(PointF pointA, PointF pointB)
		{
			//La nuova x � la media tra le due x
			float x=((pointA.X+pointB.X)/2);

			//La nuova y � la media tra le due y
			float y=((pointA.Y+pointB.Y)/2);

			//Ritono il punto medio calcolato
			return new PointF(x,y);
		}
		#endregion

		#region GetMaxDeltaX static function
		//La funzione calcola l'escursione maggiore tra le ascisse di due punti consectivi
		public static double GetMaxDeltaX(ArrayList Points)
		{
			//Inizializzo il valore che conterr� il dato da restituire
			double ret=0;
			for(int i=0; i<Points.Count-1; i++)
			{
				//Calcolo l'escursione tra i due punti consecutivi
				double Length=((PointF)Points[i]).X-((PointF)Points[i+1]).X;
				//Restituisco un valore positivo della lunghezza
				Length=(Length>0)?(Length):(-Length);
				//Controllo che la lunghezza corrente sia maggiore di quella che vorrei restituire
				if(Length>ret)
					ret=Length;
			}
			//Ritorno il valore calcolato
			return ret;
		}
		#endregion

		#region GetMaxDeltaY static function
		//La funzione calcola l'escursione maggiore tra le ordinate di due punti consectivi
		public static double GetMaxDeltaY(ArrayList Points)
		{
			//Inizializzo il valore che conterr� il dato da restituire
			double ret=0;
			for(int i=0; i<Points.Count-1; i++)
			{
				//Calcolo l'escursione tra i due punti consecutivi
				double Length=((PointF)Points[i]).Y-((PointF)Points[i+1]).Y;
				//Restituisco un valore positivo della lunghezza
				Length=(Length>0)?(Length):(-Length);
				//Controllo che la lunghezza corrente sia maggiore di quella che vorrei restituire
				if(Length>ret)
					ret=Length;
			}
			//Ritorno il valore calcolato
			return ret;
		}
		#endregion
	}
	#endregion
}