//Using statements omitted

/// <summary>
/// This class manages a list of pixel coordinates that have an intensity bright enough
/// to be a laser dot. Once a frame has finished processing by the tracker class the
/// identified coordinates are grouped together into clumps. 
/// </summary>
public class PixelList
{
	/*
	 *  CONSTANTS
	 */
	/// <summary>
	/// the minimum number of pixels in a clump to be considered part of a laser dot
	/// </summary>
	public const int NUM_PIXELS_NEEDED_FOR_LASER = 3;

	/*
	 * CLASS PROPERTIES
	 */
	/// <summary>
	/// the list of bright pixel clumps
	/// </summary>
	public List<PixelClump> PixelClumps;
	/// <summary>
	/// the maximum number of clumps
	/// </summary>
	protected int maxNumClumps;

	//possible pixel attributes
	/// <summary>
	/// the list of bright pixel positions identified by the tracker
	/// </summary>
	protected List<Point> brightPixels;
	/// <summary>
	/// the raster size of the video stream
	/// </summary>
	protected Size sourceSize;
	/// <summary>
	/// the matrix of values flags indicating which pixels
	/// have been identified as part of a pixel clump
	/// </summary>
	protected Boolean[,] identified;
	/// <summary>
	/// the matrix of laser dot weights (brightness) for each pixel
	/// </summary>
	protected ushort[,] pixelWeights;
	/// <summary>
	/// the video calibration data object
	/// </summary>
	protected CalibrationData calibrationData;
	/// <summary>
	/// the laser dot tracking object
	/// </summary>
	protected LaserDotTracking curTracker;

	/*
	 *  CONSTRUCTOR
	 */
	/// <summary>
	/// constructor for a new pixel list manager object
	/// </summary>
	/// <param name="newTracker">the laser dot tracking object</param>
	/// <param name="newData">the calibration data object</param>
	/// <param name="sourceWidth">the raster width of the video feed</param>
	/// <param name="sourceHeight">the raster height of the video feed</param>
	public PixelList(LaserDotTracking newTracker, CalibrationData newData, int sourceWidth, int sourceHeight)
	{
		curTracker = newTracker;
		calibrationData = newData;

		maxNumClumps = calibrationData.NumLasers * 2;

		sourceSize = new Size(sourceWidth, height);
		pixelWeights = new ushort[sourceSize.sourceHeight, sourceSize.Height];
		identified = new Boolean[sourceSize.Width, sourceSize.Height];
		brightPixels = new List<Point>(150);

		PixelClumps = new List<PixelClump>();
	}

	/// <summary>
	/// called when a new frame begins processing
	/// </summary>
	public void beginFrame()
	{
		brightPixels.Clear();

		for (int i = 0; i < sourceSize.Height; i++)
			for (int j = 0; j < sourceSize.Width; j++)
			{
				//set all pixels to no laser weight
				pixelWeights[j, i] = 0;
				identified[j, i] = false;
			}
	}

	/// <summary>
	/// adds a new entry to the list of pixels which are intense
	/// enough to be considered a laser pointer
	/// </summary>
	/// <param name="pos">the pixel's position</param>
	/// <param name="weight">the pixel's weight (brightness)</param>
	public void addPixel(Point pos, ushort weight)
	{
		pixelWeights[pos.X, pos.Y] = weight;
		brightPixels.Add(pos);
	}
	
	/*
	 *  PROCESS FINISHED FRAME
	 */
	/// <summary>
	/// called when a frame has finished processing
	/// by the laser dot tracking object. Processes
	/// the identified bright pixels to group them
	/// into pixel clumps
	/// </summary>
	public virtual void finishFrame()
	{
		PixelClumps.Clear();

		for (int i = 0; i < brightPixels.Count; i++)
		{
			//if the current bright pixel has not already been identified as part of another pixel clump...
			if (!identified[brightPixels[i].X, brightPixels[i].Y])
			{
				//create a new pixel clump
				PixelClump curClump = new PixelClump(false);
				
				//gets all the pixels that make up this clump
				recursiveGetPixelClump(brightPixels[i].X, brightPixels[i].Y, ref curClump);

				if (curClump.NumPixels == 0)
				{
					curClump.AveragePosition.X = 0;
					curClump.AveragePosition.Y = 0;
					curClump.AverageWeight = 0;
				}
				else
				{
					//find the average position of this clump
					curClump.AveragePosition.X = curClump.PositionSum.X / curClump.NumPixels;
					curClump.AveragePosition.Y = curClump.PositionSum.Y / curClump.NumPixels;
					curClump.AveragePosition += calibrationData.CropOffset;
					curClump.AverageWeight = curClump.TotalWeight / curClump.NumPixels;
				}

				//if the clump is large enough add it to the list of pixel clumps that represent laser dots
				if (curClump.NumPixels >= PixelList.NUM_PIXELS_NEEDED_FOR_LASER)
					PixelClumps.Add(curClump);

				//limit the number of pixel clumps
				//to prevent a stack overflow or OoM
				if(PixelClumps.Count > maxNumClumps)
					break;
			}
		}
	}

	/// <summary>
	/// recursively identifies all pixels in this
	/// bright clump by flood filling algorithm
	/// </summary>
	/// <param name="X">the current X location</param>
	/// <param name="Y">the current Y location</param>
	/// <param name="clump">the current clump of pixels</param>
	private void recursiveGetPixelClump(int X, int Y, ref PixelClump clump)
	{
		if (X >= 0 && X < sourceSize.Width &&
			Y >= 0 && Y < sourceSize.Height &&
			!identified[X, Y] &&
			pixelWeights[X, Y] > 0)
		{
			//if in bounds and not yet a part of a pixel clump and pixel weight is large enough
			identified[X, Y] = true;

			clump.TotalWeight += pixelWeights[X, Y];
			clump.PositionSum.X += X;
			clump.PositionSum.Y += Y;
			clump.NumPixels++;

			// limit number of pixels which can make up a clump
			// to prevent a stack overflow
			if (clump.NumPixels > 400)
				return; 

			//add neighbors
			recursiveGetPixelClump(X + 1, Y - 1, ref clump); //right, top
			recursiveGetPixelClump(X + 1, Y, ref clump); //right
			recursiveGetPixelClump(X + 1, Y + 1, ref clump);  //right, botom

			recursiveGetPixelClump(X, Y - 1, ref clump); //top
			recursiveGetPixelClump(X, Y + 1, ref clump); //bottom

			recursiveGetPixelClump(X - 1, Y - 1, ref clump); //left, top
			recursiveGetPixelClump(X - 1, Y, ref clump); //left
			recursiveGetPixelClump(X - 1, Y + 1, ref clump); //left, botom
		}
	}
}