< Summary - ReFlex - Library

Information
Class: Implementation.Components.TrackingManager
Assembly: ReFlex.Core.Implementation
File(s): D:\a\reflex\reflex\library\src\Core\Implementation\Components\TrackingManager.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 55
Coverable lines: 55
Total lines: 133
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 30
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
get_ChosenCamera()100%210%
get_ChosenStreamConfiguration()100%210%
get_TrackingState()100%210%
set_TrackingState(...)0%620%
.ctor(...)0%2040%
Dispose()0%2040%
ChooseCamera(...)100%210%
ChooseConfiguration(...)0%2040%
ToggleTracking()100%210%
StartTracking()0%7280%
StopTracking()0%2040%
OnFrameReady(...)0%620%
OnDepthImageReady(...)0%620%

File(s)

D:\a\reflex\reflex\library\src\Core\Implementation\Components\TrackingManager.cs

#LineLine coverage
 1using System;
 2using Implementation.Interfaces;
 3using Prism.Events;
 4using ReFlex.Core.Common.Components;
 5using ReFlex.Core.Common.Util;
 6using ReFlex.Core.Events;
 7using ReFlex.Core.Tracking.Interfaces;
 8using ReFlex.Core.Tracking.Util;
 9
 10namespace Implementation.Components
 11{
 12    public class TrackingManager : ITrackingManager, IDisposable
 13    {
 14        private readonly IEventAggregator _eventAggregator;
 15        private readonly IDepthImageManager _depthImageManager;
 16        private bool _trackingState;
 17
 018        public IDepthCamera ChosenCamera { get; private set; }
 19
 20        /// <summary>
 21        /// Gets the chosen stream configuration.
 22        /// </summary>
 23        /// <value>
 24        /// The chosen stream configuration.
 25        /// </value>
 26        /// <inheritdoc />
 027        public StreamParameter ChosenStreamConfiguration { get; private set; }
 28
 29        public event EventHandler<TrackingStateChangedEventArgs> TrackingStateChanged;
 30
 31        public bool TrackingState
 32        {
 033            get => _trackingState;
 034            set => _trackingState = value ? StartTracking() : StopTracking();
 35        }
 36
 037        public TrackingManager(IEventAggregator eventAggregator, IDepthImageManager depthImageManager)
 038        {
 039            _eventAggregator = eventAggregator;
 040            _depthImageManager = depthImageManager;
 41
 042            TrackingState = false;
 43
 044            _eventAggregator?.GetEvent<RequestChooseCameraEvent>().Subscribe(ChooseCamera);
 045            _eventAggregator?.GetEvent<RequestToggleTrackingEvent>().Subscribe(ToggleTracking);
 046        }
 47
 48        public void Dispose()
 049        {
 050            _eventAggregator?.GetEvent<RequestChooseCameraEvent>().Unsubscribe(ChooseCamera);
 051            _eventAggregator?.GetEvent<RequestToggleTrackingEvent>().Unsubscribe(ToggleTracking);
 052        }
 53
 54        public void ChooseCamera(IDepthCamera camera)
 055        {
 056            TrackingState = false;
 057            ChosenCamera = camera;
 58
 59
 060        }
 61
 62        /// <summary>
 63        /// Chooses the stream-configuration.
 64        /// </summary>
 65        /// <param name="configuration">The configuration.</param>
 66        /// <inheritdoc />
 67        public void ChooseConfiguration(StreamParameter configuration)
 068        {
 069            if (ChosenCamera == null)
 070                return;
 71
 072            if (!ChosenCamera.GetPossibleConfigurations().Contains(configuration))
 073                return;
 74
 075            ChosenStreamConfiguration = configuration;
 076            _eventAggregator.GetEvent<NotifyDepthCameraConfigurationChosenEvent>().Publish(ChosenStreamConfiguration);
 077        }
 78
 079        public void ToggleTracking() => TrackingState = !TrackingState;
 80
 81        private bool StartTracking()
 082        {
 083            if (ChosenCamera == null || ChosenStreamConfiguration == null)
 084                return false;
 85
 086            var payload = new Tuple<int, int>(ChosenStreamConfiguration.Width, ChosenStreamConfiguration.Height);
 087            _eventAggregator?.GetEvent<NotifyCameraChosenEvent>().Publish(payload);
 88
 089            _depthImageManager.Initialize(ChosenStreamConfiguration.Width, ChosenStreamConfiguration.Height);
 90
 091            ChosenCamera.EnableStream(ChosenStreamConfiguration);
 092            ChosenCamera.StartStream();
 093            ChosenCamera.FrameReady += OnFrameReady;
 094            ChosenCamera.DepthImageReady += OnDepthImageReady;
 95
 096            TrackingStateChanged?.Invoke(this, new TrackingStateChangedEventArgs(ChosenCamera, true));
 97
 098            return true;
 099        }
 100
 101        private bool StopTracking()
 0102        {
 0103            if (ChosenCamera is null)
 0104                return false;
 105
 0106            ChosenCamera.FrameReady -= OnFrameReady;
 0107            ChosenCamera.DepthImageReady -= OnDepthImageReady;
 0108            ChosenCamera.StopStream();
 109
 0110            TrackingStateChanged?.Invoke(this, new TrackingStateChangedEventArgs(ChosenCamera, false));
 111
 0112            return false;
 0113        }
 114
 115        /// <summary>
 116        /// mthod for invoking processing of depth image
 117        /// </summary>
 118        /// <param name="sender"></param>
 119        /// <param name="frame"></param>
 120        private void OnFrameReady(object sender, DepthCameraFrame frame) =>
 0121            _depthImageManager?.Update(frame);
 122
 123        /// <summary>
 124        /// Method for notifying depth data streaming instances about new data (byte data)
 125        /// </summary>
 126        /// <param name="sender"></param>
 127        /// <param name="e"></param>
 128        private void OnDepthImageReady(object sender, ImageByteArray e)
 0129        {
 0130            _depthImageManager?.Update(e);
 0131        }
 132    }
 133}