tbf/TBF/Rig/Network/Camera/CJMS11/GrabImagesOp.cs

///
/// Copyright (c) 2017 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using log4net;
using Common;
using Config.Entities;
using TBF.Rig.Network.Telnet;
using System.IO;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace TBF.Rig.Network.Camera.CJMS11
{
	public class GrabImagesOp : IOperation
	{
		/// TODO: Implement support for grabbing multiple images, now imgFileNames.Lenght should be 1
		
		private static readonly ILog log = LogManager.GetLogger(typeof(GrabImagesOp));
		public override string ToString() { return string.Format("GrabImageOp()"); }

		readonly Camera camera;
		
		readonly string[] imgFileNames;
		readonly bool blackAndWhite;
		readonly bool lowResolution;
		readonly ImageRotation imageRotation;

		string command;
		bool grabImageCommandSent;
		string response;
		
		bool transferringGrabbedImage;
		
		Image grabedImage;
		Dictionary<int, Image> grabedImages = new Dictionary<int, Image>();
		private Task<Image> grabImageTask;
		private Task saveImageTask;


		/// <summary>
		/// Events:  Event.None or Event.Error
		/// </summary>
		/// <param name="camera">CLP1611.Camera reference</param>
		public GrabImagesOp(Camera camera, string[] imgFileNames, bool blackAndWhite, bool lowResolution, ImageRotation imageRotation)
		{
			/// TODO: Implement support for grabbing multiple images, now imgFileNames.Lenght should be 1
			
			this.camera = camera;
			//this.telnet = camera.Telnet;
			this.imgFileNames = imgFileNames;
			this.blackAndWhite = blackAndWhite;
			this.lowResolution = lowResolution;
			this.imageRotation = imageRotation;

			grabImageCommandSent = false;
			transferringGrabbedImage = false;

			// /// image incomming event
   //          if (camera.DebugLevel == DebugMode.Normal || camera.DebugLevel == DebugMode.DetectedOn)
   //          {
	  //           Camera.ImageCameraHandler -= ImageReceived;
	  //           Camera.ImageCameraHandler += ImageReceived;
   //          }
            //TODO BUMI improve by simulate image
            Camera.ImageCameraHandler -= ImageReceived;
            Camera.ImageCameraHandler += ImageReceived;
            
            Camera.ImagesCameraHandler -= ImagesReceived;
            Camera.ImagesCameraHandler += ImagesReceived;
		}

		void PromptReceived(object sndr, PromptReceivedJMSEventArgs a)
		{
			response = a.Response;
		}

		private readonly object imageSync = new object();
		
		void ImageReceived(object sndr, PromptReceivedImageEventArgs a)
		{
			if (a == null || a.idxCamera != camera.CameraIdx)
				return;

			lock (imageSync)
			{
				grabedImage = a.image;
			}
		}
		
		void ImagesReceived(object sndr, PromptReceivedImagesEventArgs a)
		{
			if(a.idxCamera != camera.CameraIdx) return;
			grabedImage = a.image; //upgraded image common
			grabedImages[a.idxImage] = a.image; // stored image from sent to list of images
		}


		public void Start()
		{
			grabImageCommandSent = false;
			transferringGrabbedImage = false;

			grabedImage = null;
			grabImageTask = null;
			saveImageTask = null;

			grabedImages.Clear();

			if (imgFileNames != null &&
			    imgFileNames.Length > 0 &&
			    !string.IsNullOrEmpty(imgFileNames[0]) &&
			    File.Exists(imgFileNames[0]))
			{
				File.Delete(imgFileNames[0]);
			}
		}


		public Event Run()
		{
			if (imgFileNames == null ||
			    imgFileNames.Length < 1 ||
			    string.IsNullOrEmpty(imgFileNames[0]))
			{
				UnsubscribeEvents();
				return Event.GrabPassed;
			}

			if (!grabImageCommandSent)
			{
				log.Debug( $"Starting asynchronous grab: cameraIdx={camera.CameraIdx}");

				grabImageCommandSent = true;
				grabImageTask = camera.StartGrabImageListenerAsync();

				return Event.CameraBusy;
			}

			if (grabImageTask == null)
			{
				log.Error(
					$"Grab task was not created: cameraIdx={camera.CameraIdx}");

				UnsubscribeEvents();
				return Event.GrabFailed;
			}

			if (!grabImageTask.IsCompleted)
			{
				return Event.CameraBusy;
			}

			if (grabImageTask.IsCanceled)
			{
				log.Warn(
					$"Grab task cancelled: cameraIdx={camera.CameraIdx}");

				UnsubscribeEvents();
				return Event.GrabFailed;
			}

			if (grabImageTask.IsFaulted)
			{
				log.Error(
					$"Grab task failed: cameraIdx={camera.CameraIdx}",
					grabImageTask.Exception);

				UnsubscribeEvents();
				return Event.GrabFailed;
			}

			if (grabedImage == null)
			{
				grabedImage = grabImageTask.GetAwaiter().GetResult();
			}

			if (grabedImage == null)
			{
				log.Error(
					$"Grab completed without valid image: cameraIdx={camera.CameraIdx}");

				UnsubscribeEvents();
				return Event.GrabFailed;
			}

			if (!transferringGrabbedImage)
			{
				saveImageTask =
					camera.StartSaveImageToFileAsync(
						grabedImage,
						imgFileNames[0]);

				transferringGrabbedImage = true;

				return Event.CameraBusy;
			}

			if (saveImageTask == null)
			{
				log.Error(
					$"Save image task was not created: " +
					$"cameraIdx={camera.CameraIdx}");

				UnsubscribeEvents();
				return Event.GrabFailed;
			}

			if (!saveImageTask.IsCompleted)
			{
				return Event.CameraBusy;
			}

			if (saveImageTask.IsCanceled)
			{
				log.Warn(
					$"Save image task cancelled: " +
					$"cameraIdx={camera.CameraIdx}");

				UnsubscribeEvents();
				return Event.GrabFailed;
			}

			if (saveImageTask.IsFaulted)
			{
				log.Error(
					$"Save image task failed: " +
					$"cameraIdx={camera.CameraIdx}",
					saveImageTask.Exception);

				UnsubscribeEvents();
				return Event.GrabFailed;
			}

			bool fileSaved = File.Exists(imgFileNames[0]);

			UnsubscribeEvents();

			return fileSaved
				? Event.GrabPassed
				: Event.GrabFailed;
		}

		public void Stop()
		{
			//if (camera.CameraCfg.DebugLevel == DebugMode.Simulate) return;

			// if (camera.IsGrabImageListenerThreadAlive)
			// {
			// 	camera.SetStopGrabImageListenerFlag();
			// }
			
			camera.CancelGrabImage();
			UnsubscribeEvents();
		}
		
		private void UnsubscribeEvents()
		{
			Camera.ImageCameraHandler -= ImageReceived;
			Camera.ImagesCameraHandler -= ImagesReceived;
		}
		
		
	}
}