//Using statements omitted

/// <summary>
/// The LaserDotTracking class handles processing of video frames to identify laser dot positions.
/// It works with the calibration classes to control what pixels are identified as laser dots as well
/// as the PixelList and PixelClump classes to make these points meaningful. 
/// </summary>
public class LaserDotTracking
{
	/*
	 *  CONSTANTS
	 */
	/// <summary>
	/// modifier for the red channel's contribution to brightness
	/// </summary>
	public const ushort RED_MODIFIER = 4;
	/// <summary>
	/// modifier for the green channel's contribution to brightness
	/// </summary>
	public const ushort GREEN_MODIFIER = 2;
	/// <summary>
	/// modifier for the blue channel's contribution to brightness
	/// </summary>
	public const ushort BLUE_MODIFIER = 2;

	//red * 4 + green * 2 + blue * 2
	public const int MAX_POSSIBLE_BRIGHTNESS = 255 * (RED_MODIFIER +
													GREEN_MODIFIER +
													BLUE_MODIFIER);
	
	/*
	 *  CLASS PROPERTIES
	 */
	/// <summary>
	/// the object to store video calibration data
	/// </summary>
	private CalibrationData calibrationData;

	/// <summary>
	/// the raster size of the video feed
	/// </summary>
	private Size sourceSize;

	/// <summary>
	/// the number of lasers identified in the last frame
	/// </summary>
	private int numLasersOnScreen;

	/// <summary>
	/// the list of laser dots being tracked
	/// </summary>
	private List<LaserDot> lasers;

	/// <summary>
	/// bright pixel clump list
	/// </summary>
	private PixelList brightPixelList;

	/// <summary>
	/// the video frame used for thresholding
	/// </summary>
	private UnsafeBitmap uThresholdFrame;

	/*
	 *  CONSTRUCTOR
	 */
	/// <summary>
	/// constructor for the tracking object
	/// </summary>
	/// <param name="newData">the calibration object data</param>
	/// <param name="newLasers">the array of laser dots</param>
	public LaserDotTracking(CalibrationData newData, List<LaserDot> newLasers)
	{
		calibrationData = newData;
		lasers = newLasers;
	}

	/// <summary>
	/// unloads the laser dot tracker object
	/// </summary>
	public void unload()
	{
		uThresholdFrame.Dispose();
		lasers.Clear();
		lasers = null;
		brightPixelList = null;
		calibrationData = null;
	}

	//encapsulators omitted...

	/*
	 *  FRAME PROCESSING
	 */
	/// <summary>
	/// process a new frame of the input video
	/// </summary>
	public void ProcessFrame(Bitmap tmpImage1)
	{
		//Get width and height of source video
		if (brightPixelList == null ||
			sourceSize.Width != tmpImage1.Width ||
			sourceSize.Height != tmpImage1.Height)
		{
			sourceSize.Width = tmpImage1.Width;
			sourceSize.Height = tmpImage1.Height;

			brightPixelList = new PixelList(this, calibrationData,
									sourceSize.Width, sourceSize.Height);
		}

		//clear pixel list and prepare to process new frame
		brightPixelList.beginFrame();

		//copy image content to unsafe bitmap object
		UnsafeBitmap uBitmap = new UnsafeBitmap(tmpImage1);

		//lock memory
		uBitmap.LockBitmap();

		if (!uThresholdFrame.Locked)
			this.uThresholdFrame.LockBitmap();

		//integer variables avoid byte overflow
		int dRed; int dGreen; int dBlue;
		//for each scan line
		for (int y = 0; y < sourceSize.Height; y++)
		{
			//for each pixel in the scan line
			for (int x = 0; x < sourceSize.Width; x++)
			{
				PixelData thresholdPixel = this.uThresholdFrame.GetPixel(x, y);
				PixelData newPixel = uBitmap.GetPixel(x, y);

				//subtract brightnessThreshold pixel color from current pixel color
				dRed = (newPixel.red - thresholdPixel.red);
				dGreen = (newPixel.green - thresholdPixel.green);
				dBlue = (newPixel.blue - thresholdPixel.blue);

				//enforce zero minimum for adjusted color
				if (dRed < 0)
					dRed = 0;
				if (dGreen < 0)
					dGreen = 0;
				if (dBlue < 0)
					dBlue = 0;

				//pixel brightness function
				int brightness = (RED_MODIFIER * dRed) +
								(GREEN_MODIFIER * dGreen) +
								(BLUE_MODIFIER * dBlue);

				//if pixel is bright enough to be considered 
				// a laser dot add it to the pixel list
				if (brightness > calibrationData.Threshold)
					brightPixelList.addPixel(new Point(x, y), (ushort)(brightness));
			}
		}

		//identify laser pixel clumps
		brightPixelList.finishFrame();

		//unlock bitmap
		uBitmap.UnlockBitmap();

		//dispose frame
		uBitmap.Bitmap.Dispose();
		tmpImage1.Dispose();

		//process clumps and match them with laser dots from the previous frame
		foreach(LaserDot laser in lasers)
			if(laser.onScreen)
				laser.setClumpDistances( ref brightPixelList.PixelClumps );
		
		// iteratively approach a best solution
		// for laser dot to pixel clump matching
		Boolean changeMade = true;
		int iteration = 0;
		while (changeMade && iteration < 10)
		{
			changeMade = false;
			foreach (LaserDot laser in lasers)
			{
				if (laser.claimBestClump())
					changeMade = true;
			}
			iteration++;
		}

		//update position from best pixel clump
		foreach (LaserDot laser in lasers)
			laser.updateFromClaim();

		//check for new lasers that were not visible in the previous frame
		foreach(LaserDot laser in lasers)
			laser.checkForNewLaser( ref brightPixelList.PixelClumps );

		//total number of lasers dots in the current frame
		numLasersOnScreen = 0;
		for (int i = 0; i < lasers.Count; i++)
		{
			if (lasers[i].onScreen)
				numLasersOnScreen++;
		}
	}
}