bbiwarg-original/bbiwarg/Input/InputProviding/InputProvider.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;
using Iisu;

namespace bbiwarg.Input.InputProviding
{
    public delegate void DeviceStartedEventHandler(object sender, EventArgs e);
    public delegate void NewFrameEventHandler(object sender, NewFrameEventArgs e);

    public class NewFrameEventArgs : EventArgs
    {
        public int FrameID { get; private set; }
        public int Width { get; private set; }
        public int Height { get; private set; }
        public IntPtr RawDepthData { get; private set; }
        public IntPtr RawConfidenceData { get; private set; }

        public NewFrameEventArgs(int frameID, int width, int height, IntPtr rawDepthData, IntPtr rawConfidenceData)
        {
            FrameID = frameID;
            Width = width;
            Height = height;
            RawDepthData = rawDepthData;
            RawConfidenceData = rawConfidenceData;
        }
    }

    public class InputProvider
    {
        protected IHandle handle;
        protected IDevice device;

        protected IParameterHandle<float> frameRate;
        protected IParameterHandle<int> width;
        protected IParameterHandle<int> height;
        protected IParameterHandle<float> hfov;
        protected IParameterHandle<float> vfov;
        protected IDataHandle<Iisu.Data.IImageData> depthImage;
        protected IDataHandle<Iisu.Data.IImageData> confidenceImage;

        protected int lastFrameID;

        public int ImageWidth { get { return width.Value; } }
        public int ImageHeight { get { return height.Value; } }
        public float HFOV { get { return hfov.Value; } }
        public float VFOV { get { return vfov.Value; } }
        public bool IsActive { get; private set; }
        public virtual int CurrentFrameID { get { return device.FrameId; } }

        public event DeviceStartedEventHandler DeviceStartedEvent;
        public event NewFrameEventHandler NewFrameEvent;

        public InputProvider()
        {
            IsActive = false;
            lastFrameID = -1;
        }

        public void initialize()
        {
            createDevice();
            registerHandles();
        }

        public void start()
        {
            device.Start();
            IsActive = true;

            if (DeviceStartedEvent != null)
                DeviceStartedEvent(this, new EventArgs());

            run();
        }

        public void stop()
        {
            IsActive = false;
            device.Stop(true);
        }

        protected void createDevice()
        {
            handle = Iisu.Iisu.Context.CreateHandle();
            IDeviceConfiguration conf = createDeviceConfiguration();
            device = handle.InitializeDevice(conf);
        }

        protected virtual IDeviceConfiguration createDeviceConfiguration()
        {
            IDeviceConfiguration conf = handle.CreateDeviceConfiguration();
            conf.IsAsynchronous = false;
            return conf;
        }

        protected virtual void registerHandles()
        {
            width = device.RegisterParameterHandle<int>("SOURCE.CAMERA.DEPTH.Width");
            height = device.RegisterParameterHandle<int>("SOURCE.CAMERA.DEPTH.Height");
            hfov = device.RegisterParameterHandle<float>("SOURCE.CAMERA.DEPTH.HFOV");
            vfov = device.RegisterParameterHandle<float>("SOURCE.CAMERA.DEPTH.VFOV");
            frameRate = device.RegisterParameterHandle<float>("SOURCE.FrameRate");

            depthImage = device.RegisterDataHandle<Iisu.Data.IImageData>("SOURCE.CAMERA.DEPTH.Image");
            confidenceImage = device.RegisterDataHandle<Iisu.Data.IImageData>("SOURCE.CAMERA.CONFIDENCE.Image");
        }

        protected virtual void run()
        {
            while (IsActive)
                nextFrame();
        }

        protected virtual void nextFrame()
        {
            device.UpdateFrame(true);
            provideNewFrame();
            device.ReleaseFrame();
        }

        protected void provideNewFrame()
        {
            if (NewFrameEvent != null)
                NewFrameEvent(this, new NewFrameEventArgs(CurrentFrameID, ImageWidth, ImageHeight, depthImage.Value.Raw, confidenceImage.Value.Raw));
        }
    }
}