CameraControl.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Threading;
using System.Windows.Forms;
using AForge.Video;
using AForge.Video.DirectShow;
using Configuration;
using SharedObjects;

namespace Simple3DScan.UI
{
    public partial class CameraControl : UserControl
    {
        private bool isBusy;
        private VideoCaptureDevice videoSource;
        private readonly Dictionary<string, string> videoSources = new Dictionary<string, string>();
        private readonly Object pulseObject = new object();

        readonly SolidBrush shadowBrushDarkRed = new SolidBrush(Color.FromArgb(100, Color.Firebrick));
        readonly SolidBrush shadowBrushBlue = new SolidBrush(Color.FromArgb(25, Color.Blue));
        readonly SolidBrush shadowBrushOrange = new SolidBrush(Color.FromArgb(75, Color.Orange));
        readonly SolidBrush shadowBrushRed = new SolidBrush(Color.FromArgb(75, Color.Red));

        //private Bitmap testImage = null; 

        public bool CaptureNextImage { get; private set; }
        private Image nextImage;
        public bool FilterLaser { get; set; }
        public bool ShowLaserLine { get; set; }
        public float LaserLeftPosition { get; set; }
        public float LaserRightPosition { get; set; }
        public bool LaserMotorEnabled { get; set; }

        [Log]
        [LogException]
        public CameraControl()
        {
            if(!this.DesignMode)
                this.InitializeComponent();
        }

        [Log]
        [LogException]
        private void CameraControl_Load(object sender, EventArgs e)
        {

            //testImage = (Bitmap)Image.FromFile(".\\im.png", true);

            this.InitVideoSources();
        }

        [LogException]
        private void InitVideoSources()
        {
            foreach (FilterInfo filterInfo in new FilterInfoCollection(FilterCategory.VideoInputDevice))
            {
                this.videoSources.Add(filterInfo.Name, filterInfo.MonikerString);
            }
        }

        [Log]
        [LogException]
        public void StartImaging(string source)
        {
            if (!this.videoSources.ContainsKey(source))
            {
                this.videoSources.Clear();
                this.InitVideoSources();
                if (!this.videoSources.ContainsKey(source))
                    return;
            }

            this.StopImaging();

            this.videoSource = new VideoCaptureDevice(this.videoSources[source]);

            if (this.videoSource.VideoCapabilities.Length > 0)
            {
                VideoCapabilities max = this.videoSource.VideoCapabilities.OrderBy(p => p.FrameSize.Width).Last();
                this.videoSource.VideoResolution = max;
            }

            this.videoSource.NewFrame += this.videoSource_NewFrame;
            this.videoSource.Start();
        }


        [LogException]
        private void videoSource_NewFrame(object sender, NewFrameEventArgs eventArgs)
        {
            if (this.isBusy)
                return;

            this.isBusy = true;
            try
            {

                bool setTrap = false;
                if (this.CaptureNextImage)
                {
                    setTrap = true;
                    this.CaptureNextImage = false;
                }

                Bitmap image = (Bitmap) eventArgs.Frame.Clone();

              //  Bitmap image = (Bitmap) testImage.Clone();

                if (this.FilterLaser)
                {
                    Bitmap grayImage = TransformImage.CreateGrayImageOfLaser(image, Singleton<Config>.Instance.Information.Filter);

                    if (this.ShowLaserLine)
                    {
                        float laserPosition = TransformImage.GetLaserLinePosition(grayImage);

                        if (laserPosition > 0.0f)
                        {
                            try
                            {
                                Bitmap tempBitmap = new Bitmap(grayImage.Width, grayImage.Height);
                                using (Graphics graphics = Graphics.FromImage(tempBitmap))
                                {
                                    graphics.DrawImage(grayImage, 0, 0);
                                    graphics.FillRectangle(this.shadowBrushDarkRed,
                                        new RectangleF(laserPosition - 2, 0, 4, grayImage.Height));
                                }
                                this.pictureBoxCameraImage.Image = tempBitmap;
                            }
                            catch (Exception ex)
                            {
                            }
                        }
                        else
                        {
                            this.pictureBoxCameraImage.Image = grayImage;
                        }
                    }
                    else
                    {
                        this.pictureBoxCameraImage.Image = grayImage;
                    }
                }
                else
                {
                    using (Graphics graphics = Graphics.FromImage(image))
                    {
                        int middle = image.Width/2;

                        float pixelPerCM = (float)Singleton<Config>.Instance.Information.Camera.Width/Singleton<Config>.Instance.Information.Camera.WorldWidth;
                        float turntableXRadius = (float)Singleton<Config>.Instance.Information.Turntable.Radius * pixelPerCM;

                        RectangleF turntableRectangleF = new RectangleF
                        {
                            X = middle - turntableXRadius,
                            Width = 2*turntableXRadius,
                            Y = image.Height*0.75f,
                            Height = turntableXRadius/1.66f/((float)image.Width/(float)image.Height)
                        };
                       
                        graphics.FillEllipse(this.shadowBrushBlue, turntableRectangleF);
                        
                       // graphics.FillRectangle(this.shadowBrushBlue, new RectangleF(175, 715, 900, 210));
                        // show where the table should be aligned to

                        if (this.LaserMotorEnabled)
                        {
                            graphics.FillRectangle(this.shadowBrushOrange,
                                new RectangleF(this.LaserLeftPosition - 2, 0, 4, image.Height));
                            graphics.FillRectangle(this.shadowBrushRed,
                                new RectangleF(this.LaserRightPosition - 2, 0, 4, image.Height));
                        }

                        if (this.ShowLaserLine)
                        {
                            float laserPosition = TransformImage.GetLaserLinePosition(image,
                                Singleton<Config>.Instance.Information.Filter);

                            graphics.FillRectangle(this.shadowBrushDarkRed,
                                new RectangleF(laserPosition - 2, 0, 4, image.Height));
                        }
                    }

                    this.pictureBoxCameraImage.Image = image;
                }
           
                if (!setTrap) 
                    return;
                this.nextImage = (Image)eventArgs.Frame.Clone();
                lock (this.pulseObject)
                    Monitor.Pulse(this.pulseObject);
            }
            finally
            {
                this.isBusy = false;
            }
        }

        [Log]
        [LogException]
        public void StopImaging()
        {
            if (this.videoSource == null || !this.videoSource.IsRunning) 
                return;

            this.videoSource.SignalToStop();
            this.videoSource = null;
        }

        [Log]
        [LogException]
        internal Image GetNextPicture()
        {
            lock (this.pulseObject)
            {
                this.CaptureNextImage = true;
                Monitor.Wait(this.pulseObject);
            }
            lock (this.pulseObject)
            {
                this.CaptureNextImage = true;
                Monitor.Wait(this.pulseObject);
            }
            return this.nextImage;
        }

    }
}