ScanControl.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using AForge.Video.DirectShow;
using ArduinoConnection;
using Configuration;
using PointWriter;
using SharedObjects;
using Syncfusion.Windows.Forms.Tools;

namespace Simple3DScan.UI
{
    public partial class ScanControl : UserControl
    {
        #region fields

        protected readonly BackgroundWorker ScanWorker = new BackgroundWorker();

        protected readonly Information ConfigurationInformation = Singleton<Config>.Instance.Information;

        public ArduinoCommands Arduino { get; set; }

        protected readonly Dictionary<string, string> VideoSources = new Dictionary<string, string>();

        #endregion

        #region events
        public delegate void StartScan();
        public event StartScan StartScanning;
        public delegate void StopScan();
        public event StopScan StopScanning;
        #endregion

        #region Constructor

        [Log]
        [LogException]
        public ScanControl()
        {
            this.InitializeComponent();
        }

        #endregion

        #region load

        [Log]
        [LogException]
        private void ScanControl_Load(object sender, EventArgs e)
        {
            if(!this.DesignMode)
                this.InitiateCameraDropdown();
        }

        [Log]
        [LogException]
        public void Init(ArduinoCommands arduino)
        {
            this.Arduino = arduino;
            this.Arduino.ActivateLaser(false);

            ButtonRenderer styleRenderer = new ButtonRenderer();
            this.ToggleButtonCapture.Renderer = styleRenderer;

            this.RadialSliderPrecision.ValueChanged += this.RadialSliderPrecision_ValueChanged;
           
        }

        [Log]
        [LogException]
        protected void InitiateCameraDropdown()
        {
            int i = 0;
            foreach (FilterInfo filterInfo in new FilterInfoCollection(FilterCategory.VideoInputDevice))
            {
                this.ComboBoxCameras.Items.Add(filterInfo.Name);
                this.VideoSources.Add(filterInfo.Name, filterInfo.MonikerString);
                if (!String.IsNullOrEmpty(this.ConfigurationInformation.Camera.Name) &&
                    filterInfo.Name == this.ConfigurationInformation.Camera.Name)
                    this.ComboBoxCameras.SelectedIndex = i;
                i++;
            }
        }

        [Log]
        [LogException]
        private void buttonRefreshCams_Click(object sender, EventArgs e)
        {
            this.ComboBoxCameras.Items.Clear();
            this.VideoSources.Clear();
            this.InitiateCameraDropdown();
            this.ConfigurationInformation.Camera.Name = this.ComboBoxCameras.SelectedItem.ToString();
            this.ImagingControl.StartImaging(this.ConfigurationInformation.Camera.Name);
        }

        #endregion

        #region dispose
        [Log]
        [LogException]
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                this.components?.Dispose();
            }
            this.ImagingControl.StopImaging();

            base.Dispose(disposing);
        }
        #endregion

        #region background job
        [Log]
        [LogException]
        protected void ScanWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            this.StartScanning?.Invoke();
            Precision precision = (Precision)e.Argument;

            string imageFolder = ResetImageFolder(this.ConfigurationInformation);

            int numberOfTotalSteps;
            Resolution resolution;
            GetResolutionAndSteps(precision, this.ConfigurationInformation, out numberOfTotalSteps, out resolution);

            MoveLaserToLeftStartPosition(this.Arduino, this.ImagingControl, this.ConfigurationInformation);

            IPointWriter writer;
            if (!this.InitiateWriter(this.Arduino, this.ConfigurationInformation, out writer))
                return;

            if (this.PerformScan(this.Arduino, this.ImagingControl, this.ConfigurationInformation, numberOfTotalSteps, resolution, imageFolder, writer)) return;

            if (this.ConfigurationInformation.Places.FileFormat == FileFormat.Ascii)
                this.Arduino.ActivateLaser(false);

            SavePoints(this, writer, this.ConfigurationInformation);
        }

        [LogException]
        protected void ScanWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            this.RadialGaugeProgress.Value = e.ProgressPercentage;
        }

        [Log]
        [LogException]
        protected virtual void ScanWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            this.StopScanning?.Invoke();

            this.ToggleButtonCapture.ToggleState = ToggleButtonState.Inactive;
            this.ScanWorker.DoWork -= this.ScanWorker_DoWork;
            this.ScanWorker.ProgressChanged -= this.ScanWorker_ProgressChanged;
            this.ScanWorker.RunWorkerCompleted -= this.ScanWorker_RunWorkerCompleted;
            this.Arduino.ActivateLaser(false);
        }

        #endregion

        #region controls
        [Log]
        [LogException]
        protected void ToggleButtonCapture_Click(object sender, EventArgs e)
        {
            this.RadialGaugeProgress.Value = 0;

            if (this.ScanWorker.IsBusy != true)
            {
                this.ScanWorker.DoWork += this.ScanWorker_DoWork;
                this.ScanWorker.ProgressChanged += this.ScanWorker_ProgressChanged;
                this.ScanWorker.RunWorkerCompleted += this.ScanWorker_RunWorkerCompleted;
                this.ScanWorker.WorkerReportsProgress = true;
                this.ScanWorker.WorkerSupportsCancellation = true;
                this.ScanWorker.RunWorkerAsync((Precision)this.RadialSliderPrecision.Value);
            }
            else
                this.ScanWorker.CancelAsync();
        }

        [Log]
        [LogException]
        protected void ComboBoxCameras_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (!this.VideoSources.ContainsKey(this.ComboBoxCameras.SelectedItem.ToString()))
                return;

            this.ConfigurationInformation.Camera.Name = this.ComboBoxCameras.SelectedItem.ToString();
            this.ConfigurationInformation.Camera.Moniker = this.VideoSources[this.ComboBoxCameras.SelectedItem.ToString()];

            this.SetMaxFrameSizes(this.ConfigurationInformation.Camera.Moniker);

            this.ImagingControl.LaserMotorEnabled = this.ConfigurationInformation.Laser.MotorEnabled;
            this.ImagingControl.LaserLeftPosition = this.ConfigurationInformation.Laser.SwipeMin * this.ConfigurationInformation.Camera.Width / 100;
            this.ImagingControl.LaserRightPosition = this.ConfigurationInformation.Laser.SwipeMax * this.ConfigurationInformation.Camera.Width / 100;

            this.ImagingControl.StartImaging(this.ConfigurationInformation.Camera.Name);
        }

        [Log]
        [LogException]
        private void SetMaxFrameSizes(string monikerString)
        {
            VideoCaptureDevice source = new VideoCaptureDevice(monikerString);

            if (source.VideoCapabilities.Length > 0)
            {
                VideoCapabilities max = source.VideoCapabilities.OrderBy(p => p.FrameSize.Width).Last();
                source.VideoResolution = max;
            }
            if (null != source.VideoResolution)
            {
                this.ConfigurationInformation.Camera.Height = source.VideoResolution.FrameSize.Height;
                this.ConfigurationInformation.Camera.Width = source.VideoResolution.FrameSize.Width;
            }
        }

        #endregion

        #region scan

        [Log]
        [LogException]
        protected IEnumerable<ColorPoint3D> ScanImage(int actualSteps, string imageFolder, int steps, int sweep, ArduinoCommands arduino, CameraControl imaging, Information configuration)
        {
            Image image;
            Image imageOff = null;
            List<ColorPoint3D> points = new List<ColorPoint3D>();

            if (!configuration.Laser.MotorEnabled)
            {
                if (configuration.Places.FileFormat == FileFormat.Pcd)
                {
                    arduino.ActivateLaser(false);

                    image = imaging.GetNextPicture();

                    imageOff = (Image) image.Clone();
                    imageOff.SaveImage(imageFolder, "OffLaserLight", actualSteps, configuration); // for autodesk 123d

                    arduino.ActivateLaser();
                }

                image = imaging.GetNextPicture();

                if (configuration.Places.FileFormat == FileFormat.Pcd)
                    arduino.ActivateLaser(false);

                image.SaveImage(imageFolder, "OnLaserLight", actualSteps, configuration);

                image = TransformImage.CreateGrayImageOfLaser((Bitmap) image, configuration.Filter);
                image.SaveImage(imageFolder, "LaserLight", actualSteps, configuration);

                Image skeletonImage = TransformImage.SimpleSkeletonizationImage((Bitmap) image);
                skeletonImage.SaveImage(imageFolder, "Skeleton", actualSteps, configuration);

                points = TransformImage.TransformStepImage(skeletonImage, imageOff, actualSteps,
                    configuration.Motor.MicroStepsEnabled, configuration);
            }

            if (configuration.Laser.MotorEnabled)
            {
                if (configuration.Places.FileFormat == FileFormat.Pcd)
                    arduino.ActivateLaser();

                image = imaging.GetNextPicture();

                float actualX = TransformImage.GetLaserLinePosition(image, configuration.Filter);
                bool swipeRight = actualX <= configuration.Laser.SwipeMin*configuration.Camera.Width/100;

                if (swipeRight)
                {
                    while (TransformImage.GetLaserLinePosition(image, configuration.Filter) <
                           configuration.Laser.SwipeMax*configuration.Camera.Width/100)
                    {
                        if (this.ScanWorker.CancellationPending)
                            return null;

                        arduino.RotateLaserCw(sweep);
                        
                        image = CaptureSweepImage(actualSteps, imaging, configuration, ref points);
                    }
                }
                else
                {
                    while (TransformImage.GetLaserLinePosition(image, configuration.Filter) >
                           configuration.Laser.SwipeMin*configuration.Camera.Width/100)
                    {
                        if (this.ScanWorker.CancellationPending)
                            return null;

                        arduino.RotateLaserCcw(sweep);

                        image = CaptureSweepImage(actualSteps, imaging, configuration, ref points);
                    }
                }
            }
            arduino.RotateTurnTableCw(steps);

            return points;
        }

       [LogException]
        private static Image CaptureSweepImage(int actualSteps, CameraControl imaging, Information configuration, ref List<ColorPoint3D> points)
        {
            Image image = imaging.GetNextPicture();
            image = TransformImage.CreateGrayImageOfLaser((Bitmap)image, configuration.Filter);
            Image skeletonImage = TransformImage.SimpleSkeletonizationImage((Bitmap)image);

            points.AddRange(TransformImage.TransformStepImage(skeletonImage, null, actualSteps,
                configuration.Motor.MicroStepsEnabled, configuration));

            image = imaging.GetNextPicture();
            return image;
        }

       [Log]
       [LogException]
       protected bool PerformScan(ArduinoCommands arduino, CameraControl cameraControl, Information configuration, int numberOfTotalSteps, Resolution resolution, string imageFolder, IPointWriter writer)
        {
            for (int actualSteps = 0; actualSteps <= numberOfTotalSteps; actualSteps += resolution.Steps)
            {
                if (this.ScanWorker.CancellationPending)
                    return true;

                int percentage = actualSteps*100/numberOfTotalSteps;

                IEnumerable<ColorPoint3D> points = this.ScanImage(actualSteps, imageFolder, resolution.Steps, resolution.SweepSteps, arduino, cameraControl, configuration);

                if(null != points)
                    foreach (ColorPoint3D point in points)
                        writer.AddPoint(point);

                this.ScanWorker.ReportProgress(percentage);
            }
            return false;
        }

        #endregion

        #region laser

       [Log]
       [LogException]
       protected static void MoveLaserToLeftStartPosition(ArduinoCommands arduino, CameraControl cameraControl, Information configuration)
        {
            if (!configuration.Laser.MotorEnabled)
                return;
            arduino.ActivateLaser();

            float actualX = TransformImage.GetLaserLinePosition(cameraControl.GetNextPicture(), configuration.Filter);

            while (actualX > configuration.Laser.SwipeMin*configuration.Camera.Width/100)
            {
                arduino.RotateLaserCcw(4);
                actualX = TransformImage.GetLaserLinePosition(cameraControl.GetNextPicture(), configuration.Filter);
            }
            arduino.RotateLaserCcw(4);
            arduino.ActivateLaser(false);
        }

        #endregion

        #region resolution

        [Log]
        [LogException]
        protected static void GetResolutionAndSteps(Precision precision, Information configuration, out int numberOfTotalSteps, out Resolution resolution)
        {
            numberOfTotalSteps = configuration.Motor.MicroStepsEnabled
                ? configuration.Motor.MicroSteps*configuration.Motor.Steps
                : configuration.Motor.Steps;

            resolution = configuration.Resolutions.First(x => x.Precision == precision);
        }

        #endregion

        #region writer

        [Log]
        [LogException]
        protected static string ResetImageFolder(Information configuration)
        {
            string imageFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
                configuration.Places.ImageSubPath);

            FileHelper.CreatePathIfNotExisting(imageFolder);

            FileHelper.DeleteAllFilesInFolder(imageFolder);
            return imageFolder;
        }

        [Log]
        [LogException]
        protected bool InitiateWriter(ArduinoCommands arduino, Information configuration, out IPointWriter writer)
        {
            switch (configuration.Places.FileFormat)
            {
                case FileFormat.Ascii:
                    arduino.ActivateLaser();
                    writer = new WriterAsc();
                    break;
                case FileFormat.Pcd:
                    writer = new WriterPcd();
                    break;
                default:
                    writer = null;
                    return false;
            }
            return true;
        }

        [Log]
        [LogException]
        protected static void SavePoints(Control control, IPointWriter writer, Information configuration)
        {
            control.Invoke((MethodInvoker) delegate
            {
                SaveFileDialog saveDialog = new SaveFileDialog();
                if (!String.IsNullOrEmpty(configuration.Places.ImageSubPath))
                    saveDialog.InitialDirectory = configuration.Places.ImageSubPath;

                switch (configuration.Places.FileFormat)
                {

                    case FileFormat.Pcd:
                        saveDialog.DefaultExt = ".PLY";
                        saveDialog.Filter = "PLY (.ply)|*.ply";
                        saveDialog.FileName = "ColoredPoints" + DateTime.Now.ToFileTime();
                        break;
                    default:
                        saveDialog.DefaultExt = ".asc";
                        saveDialog.Filter = "Ascii (.asc)|*.asc";
                        saveDialog.FileName = "Points" + DateTime.Now.ToFileTime();
                        break;
                }

                DialogResult result = saveDialog.ShowDialog();

                if (result != DialogResult.OK)
                    return;

                string filename = saveDialog.FileName;
                configuration.Places.LastFilePath = Path.GetDirectoryName(filename);
                writer.Write(filename);
            });
        }

        #endregion

        #region start stop
        [Log]
        [LogException]
        internal void Stop()
        {
            this.ImagingControl.StopImaging();
            if (this.ScanWorker.IsBusy)
                this.ScanWorker.CancelAsync();
        }

        [Log]
        [LogException]
        internal void Start()
        {
            this.ImagingControl.StartImaging(this.ConfigurationInformation.Camera.Name);
        }

        private void RadialSliderPrecision_ValueChanged(object sender, RadialSlider.ValueChangedEventArgs args)
        {
            this.RadialSliderPrecision.ValueChanged -= this.RadialSliderPrecision_ValueChanged;

            int testValue = (int)Math.Round(this.RadialSliderPrecision.Value);
            this.RadialSliderPrecision.Value = testValue;

            this.RadialSliderPrecision.ValueChanged += this.RadialSliderPrecision_ValueChanged;
        }
        #endregion
    }
}