< Summary - ReFlex - Library

Information
Class: Implementation.Components.InteractionManager
Assembly: ReFlex.Core.Implementation
File(s): D:\a\reflex\reflex\library\src\Core\Implementation\Components\InteractionManager.cs
Line coverage
38%
Covered lines: 84
Uncovered lines: 136
Coverable lines: 220
Total lines: 412
Line coverage: 38.1%
Branch coverage
20%
Covered branches: 22
Total branches: 107
Branch coverage: 20.5%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
get_Interactions()0%620%
get_Type()0%620%
set_Type(...)40%7558.33%
ComputeZeroPlaneDistance()0%620%
UpdateObserver(...)100%4496.77%
OnHistoryUpdated(...)0%620%
get_Distance()0%620%
set_Distance(...)0%620%
get_MinDistance()0%620%
set_MinDistance(...)0%620%
get_MaxDistance()0%620%
set_MaxDistance(...)0%620%
get_MinAngle()0%620%
set_MinAngle(...)0%620%
get_MinConfidence()0%620%
set_MinConfidence(...)0%620%
get_MaxConfidence()0%620%
set_MaxConfidence(...)0%620%
get_InteractionHistorySize()0%620%
set_InteractionHistorySize(...)0%620%
get_NumSmoothingFrames()0%620%
set_NumSmoothingFrames(...)0%620%
get_MaxNumEmptyFramesBetween()0%620%
set_MaxNumEmptyFramesBetween(...)0%620%
get_TouchMergeDistance2D()0%620%
set_TouchMergeDistance2D(...)0%620%
get_DepthScale()0%620%
set_DepthScale(...)0%620%
get_FilterType()0%620%
set_FilterType(...)0%620%
get_ExtremumTypeCheckNumSamples()50%22100%
set_ExtremumTypeCheckNumSamples(...)100%22100%
get_ExtremumTypeCheckRadius()50%22100%
set_ExtremumTypeCheckRadius(...)100%22100%
get_ExtremumTypeCheckFittingPercentage()50%22100%
set_ExtremumTypeCheckFittingPercentage(...)100%22100%
get_ExtremumTypeCheckMethod()50%22100%
set_ExtremumTypeCheckMethod(...)100%22100%
get_PointCloud()0%620%
set_PointCloud(...)100%210%
get_VectorField()0%620%
set_VectorField(...)100%210%
get_InputDistance()100%210%
Init(...)100%210%
Update()0%2040%
Dispose()100%44100%
OnPointcloudChanged(...)0%620%
OnVectorfieldChanged(...)0%620%
OnNewInteractions(...)0%620%
RemoveClusteredInteractions(...)0%7280%

File(s)

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

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Linq;
 4using System.Threading.Tasks;
 5using Implementation.Interfaces;
 6using ReFlex.Core.Common.Components;
 7using ReFlex.Core.Common.Interfaces;
 8using ReFlex.Core.Common.Util;
 9using ReFlex.Core.Interactivity.Components;
 10using ReFlex.Core.Interactivity.Interfaces;
 11using ReFlex.Core.Interactivity.Util;
 12
 13namespace Implementation.Components
 14{
 15    public class InteractionManager : IInteractionManager, IDisposable
 16    {
 17        private IInteractionObserver _interactionObserver;
 18        private IList<Interaction> _interactions;
 19        private readonly IDepthImageManager _depthImageManager;
 20        private readonly IPerformanceAggregator _performanceAggregator;
 21
 22        private readonly IRemoteInteractionProcessorService _service;
 23
 24        private float _distance;
 25        private float _minDistance;
 26        private float _maxDistance;
 27        private float _minAngle;
 28        private int _minConfidence;
 29        private int _maxConfidence;
 30        private int _numSmoothFrames;
 31        private int _interactionHistorySize;
 32        private int _maxNumEmptyFramesBetween;
 233        private float _smoothingDistanceSquared = 64f;
 234        private float _depthScale = 100.0f;
 35        private int _extremumTypeCheckNumSamples;
 36        private int _extremumTypeCheckRadius;
 37        private float _extremumTypeCheckFittingPercentage;
 38        private ExtremumTypeCheckMethod _extremumTypeCheckMethod;
 39
 040        public IList<Interaction> Interactions => _interactions ?? new List<Interaction>();
 41
 42        public ObserverType Type
 43        {
 044            get => _interactionObserver?.Type ?? ObserverType.None;
 45            set
 846            {
 847                switch (value)
 48                {
 49                    case ObserverType.Remote:
 450                        UpdateObserver(new RemoteInteractionProcessor(_service));
 451                        break;
 52                    case ObserverType.MultiTouch:
 453                        UpdateObserver(new MultiInteractionObserver());
 54
 455                        break;
 56                    case ObserverType.SingleTouch:
 057                        UpdateObserver(new SingleInteractionObserver());
 58
 059                        break;
 60                    case ObserverType.None:
 061                        UpdateObserver(new NoInteractionObserver());
 062                        break;
 63                    default:
 064                        throw new ArgumentOutOfRangeException(nameof(value), value, null);
 65                }
 866            }
 67        }
 68
 69        public float ComputeZeroPlaneDistance()
 070        {
 071            if (_interactionObserver == null)
 072                return 0;
 73
 074            return _interactionObserver.CalculateAverageDistance();
 075        }
 76
 77        private void UpdateObserver(IInteractionObserver observer)
 878        {
 879            if (_interactionObserver != null)
 680            {
 681                _interactionObserver.NewInteractions -= OnNewInteractions;
 682                _interactionObserver.InteractionHistoryUpdated -= OnHistoryUpdated;
 683                _performanceAggregator.UnregisterReporter(observer as IPerformanceReporter);
 684            }
 85
 886            if (observer == null)
 087                return;
 88
 889            observer.Distance = _distance;
 890            observer.MinDistance = _minDistance;
 891            observer.MaxDistance = _maxDistance;
 892            observer.MinConfidence = _minConfidence;
 893            observer.MaxConfidence = _maxConfidence;
 894            observer.MinAngle = _minAngle;
 895            observer.PointCloud = _depthImageManager.PointCloud;
 896            observer.VectorField = _depthImageManager.VectorField;
 897            observer.NumSmoothingFrames = _numSmoothFrames;
 898            observer.InteractionHistorySize = _interactionHistorySize;
 899            observer.TouchMergeDistance2D = _smoothingDistanceSquared;
 8100            observer.MaxNumEmptyFramesBetween = _maxNumEmptyFramesBetween;
 8101            observer.DepthScale = _depthScale;
 8102            observer.ExtremumTypeCheckRadius = _extremumTypeCheckRadius;
 8103            observer.ExtremumTypeCheckNumSamples = _extremumTypeCheckNumSamples;
 8104            observer.ExtremumTypeCheckFittingPercentage = _extremumTypeCheckFittingPercentage;
 8105            observer.ExtremumTypeCheckMethod = _extremumTypeCheckMethod;
 8106            _interactionObserver = observer;
 107
 8108            _interactionObserver.NewInteractions += OnNewInteractions;
 8109            _interactionObserver.InteractionHistoryUpdated += OnHistoryUpdated;
 8110            _performanceAggregator.RegisterReporter(_interactionObserver as IPerformanceReporter);
 8111        }
 112
 113        private void OnHistoryUpdated(object sender, IList<InteractionFrame> e)
 0114        {
 0115            InteractionHistoryUpdated?.Invoke(this, e);
 0116        }
 117
 118        public float Distance
 119        {
 0120            get => _interactionObserver?.Distance ?? 0;
 121            set
 0122            {
 0123                if (_interactionObserver != null)
 0124                    _interactionObserver.Distance = value;
 125
 0126                _distance = value;
 0127            }
 128        }
 129
 130        public float MinDistance
 131        {
 0132            get => _interactionObserver?.MinDistance ?? 0;
 133            set
 0134            {
 0135                if (_interactionObserver != null)
 0136                    _interactionObserver.MinDistance = value;
 137
 0138                _minDistance = value;
 0139            }
 140        }
 141
 142        public float MaxDistance
 143        {
 0144            get => _interactionObserver?.MaxDistance ?? 0;
 145            set
 0146            {
 0147                if (_interactionObserver != null)
 0148                    _interactionObserver.MaxDistance = value;
 149
 0150                _maxDistance = value;
 0151            }
 152        }
 153
 154        public float MinAngle
 155        {
 0156            get => _interactionObserver?.MinAngle ?? 0;
 157            set
 0158            {
 0159                if (_interactionObserver != null)
 0160                    _interactionObserver.MinAngle = value;
 161
 0162                _minAngle = value;
 0163            }
 164        }
 165
 166        public int MinConfidence
 167        {
 0168            get => (int)(_interactionObserver?.MinConfidence ?? 0);
 169            set
 0170            {
 0171                if (_interactionObserver != null)
 0172                    _interactionObserver.MinConfidence = value;
 173
 0174                _minConfidence = value;
 0175            }
 176        }
 177
 178        public int MaxConfidence
 179        {
 0180            get => (int)(_interactionObserver?.MaxConfidence ?? 0);
 181            set
 0182            {
 0183                if (_interactionObserver != null)
 0184                    _interactionObserver.MaxConfidence = value;
 185
 0186                _maxConfidence = value;
 0187            }
 188        }
 189
 190        public int InteractionHistorySize
 191        {
 0192            get => _interactionObserver?.InteractionHistorySize ?? 0;
 193            set
 0194            {
 0195                if (_interactionObserver != null)
 0196                    _interactionObserver.InteractionHistorySize = value;
 197
 0198                _interactionHistorySize = value;
 0199            }
 200        }
 201
 202        public int NumSmoothingFrames
 203        {
 0204            get => _interactionObserver?.NumSmoothingFrames ?? 0;
 205            set
 0206            {
 0207                if (_interactionObserver != null)
 0208                    _interactionObserver.NumSmoothingFrames = value;
 209
 0210                _numSmoothFrames = value;
 0211            }
 212        }
 213
 214        public int MaxNumEmptyFramesBetween
 215        {
 0216            get => _interactionObserver?.MaxNumEmptyFramesBetween ?? 0;
 217            set
 0218            {
 0219                if (_interactionObserver != null)
 0220                    _interactionObserver.MaxNumEmptyFramesBetween = value;
 221
 0222                _maxNumEmptyFramesBetween = value;
 0223            }
 224        }
 225
 226        public float TouchMergeDistance2D
 227        {
 0228            get => _interactionObserver?.TouchMergeDistance2D ?? 0f;
 229            set
 0230            {
 0231                if (_interactionObserver != null)
 0232                    _interactionObserver.TouchMergeDistance2D = value;
 233
 0234                _smoothingDistanceSquared = value;
 0235            }
 236        }
 237
 238        public float DepthScale
 239        {
 0240            get => _interactionObserver?.DepthScale ?? 0f;
 241            set
 0242            {
 0243                if (_interactionObserver != null)
 0244                    _interactionObserver.DepthScale = value;
 245
 0246                _depthScale = value;
 0247            }
 248        }
 249
 250        public FilterType FilterType {
 0251            get => _interactionObserver?.FilterType ?? FilterType.None;
 252            set
 0253            {
 0254                if (_interactionObserver != null)
 0255                    _interactionObserver.FilterType = value;
 0256            }
 257        }
 258
 259        public int ExtremumTypeCheckNumSamples
 260        {
 2261            get => _interactionObserver?.ExtremumTypeCheckNumSamples ?? _extremumTypeCheckNumSamples;
 262            set
 4263            {
 4264                if (_interactionObserver != null)
 2265                    _interactionObserver.ExtremumTypeCheckNumSamples = value;
 4266                _extremumTypeCheckNumSamples = value;
 4267            }
 268        }
 269
 270        public int ExtremumTypeCheckRadius
 271        {
 2272            get => _interactionObserver?.ExtremumTypeCheckRadius ?? _extremumTypeCheckRadius;
 273            set
 4274            {
 4275                if (_interactionObserver != null)
 2276                    _interactionObserver.ExtremumTypeCheckRadius = value;
 4277                _extremumTypeCheckRadius = value;
 4278            }
 279        }
 280
 281        public float ExtremumTypeCheckFittingPercentage
 282        {
 2283            get => _interactionObserver?.ExtremumTypeCheckFittingPercentage ?? _extremumTypeCheckFittingPercentage;
 284            set
 4285            {
 4286                if (_interactionObserver != null)
 2287                    _interactionObserver.ExtremumTypeCheckFittingPercentage = value;
 4288                _extremumTypeCheckFittingPercentage = value;
 4289            }
 290        }
 291
 292        public ExtremumTypeCheckMethod ExtremumTypeCheckMethod
 293        {
 2294            get => _interactionObserver?.ExtremumTypeCheckMethod ?? _extremumTypeCheckMethod;
 295            set
 4296            {
 4297                if (_interactionObserver != null)
 2298                    _interactionObserver.ExtremumTypeCheckMethod = value;
 4299                _extremumTypeCheckMethod = value;
 4300            }
 301        }
 302
 303        public PointCloud3 PointCloud
 304        {
 0305            get => _interactionObserver?.PointCloud;
 0306            set => _interactionObserver.PointCloud = value;
 307        }
 308
 309        public VectorField2 VectorField
 310        {
 0311            get => _interactionObserver?.VectorField;
 0312            set => _interactionObserver.VectorField = value;
 313        }
 314
 0315        public float InputDistance { get; set; }
 316
 2317        public InteractionManager(IDepthImageManager depthImageManager, IRemoteInteractionProcessorService service, IPer
 2318        {
 2319            _depthImageManager = depthImageManager;
 2320            _service = service;
 2321            _performanceAggregator = performanceAggregator;
 322
 2323            depthImageManager.PointcloudFiltered += OnPointcloudChanged;
 2324            depthImageManager.VectorfieldChanged += OnVectorfieldChanged;
 2325        }
 326
 327        public void Init(ObserverType type)
 0328        {
 0329            Type = type;
 0330        }
 331
 332        public async Task<ProcessServiceStatus> Update()
 0333        {
 0334            if (_interactionObserver == null)
 0335                return ProcessServiceStatus.Error;
 336
 0337            return (await _interactionObserver.Update())?.ServiceStatus ?? ProcessServiceStatus.Error;
 0338        }
 339
 340        public event EventHandler<IList<Interaction>> InteractionsUpdated;
 341
 342        public event EventHandler<IList<InteractionFrame>> InteractionHistoryUpdated;
 343
 344        public void Dispose()
 2345        {
 2346            if (_depthImageManager != null)
 2347            {
 2348                _depthImageManager.PointcloudFiltered -= OnPointcloudChanged;
 2349                _depthImageManager.VectorfieldChanged -= OnVectorfieldChanged;
 2350            }
 351
 2352            if (_interactionObserver != null)
 2353            {
 2354                _interactionObserver.NewInteractions -= OnNewInteractions;
 2355                _interactionObserver.InteractionHistoryUpdated -= OnHistoryUpdated;
 356
 2357                _performanceAggregator.UnregisterReporter(_interactionObserver as IPerformanceReporter);
 2358            }
 2359        }
 360
 361        private void OnPointcloudChanged(object sender, PointCloud3 source)
 0362        {
 0363            if (_interactionObserver != null)
 0364                _interactionObserver.PointCloud = source;
 0365        }
 366
 367        private void OnVectorfieldChanged(object sender, VectorField2 source)
 0368        {
 0369            if (_interactionObserver != null)
 0370                _interactionObserver.VectorField = source;
 0371        }
 372
 373        private void OnNewInteractions(object sender, IList<Interaction> interactions)
 0374        {
 0375            lock (interactions)
 0376            {
 0377                var copy = interactions.Select(interaction => new Interaction(interaction)).ToList();
 0378                _interactions = RemoveClusteredInteractions(copy);
 0379            }
 380
 0381            InteractionsUpdated?.Invoke(this, _interactions);
 0382        }
 383
 384        private IList<Interaction> RemoveClusteredInteractions(IList<Interaction> rawInteractions)
 0385        {
 0386            var filteredCopy = new List<Interaction>();
 387
 0388            for (var i = 0; i < rawInteractions.Count; i++)
 0389            {
 0390                var currPt = rawInteractions[i];
 0391                var distances = filteredCopy.Select(inter => Point3.Squared2DDistance(inter.Position, currPt.Position)).
 392
 0393                var addPoint = true;
 394
 0395                for (var j = 0; j < distances.Count; j++)
 0396                {
 0397                    var distance = distances[j];
 0398                    if (distance < InputDistance)
 0399                    {
 0400                        addPoint = false;
 0401                        break;
 402                    }
 0403                }
 0404                if (addPoint)
 0405                    filteredCopy.Add(currPt);
 0406            }
 0407            return filteredCopy;
 0408        }
 409
 410
 411    }
 412}
Generated by: ReportGenerator 5.5.12.0
11/3/2026 - 3:18:15 PM
GitHub | reportgenerator.io

Methods/Properties

.ctor(Implementation.Interfaces.IDepthImageManager,ReFlex.Core.Interactivity.Interfaces.IRemoteInteractionProcessorService,ReFlex.Core.Common.Interfaces.IPerformanceAggregator)
get_Interactions()
get_Type()
set_Type(ReFlex.Core.Common.Util.ObserverType)
ComputeZeroPlaneDistance()
UpdateObserver(ReFlex.Core.Interactivity.Interfaces.IInteractionObserver)
OnHistoryUpdated(System.Object,System.Collections.Generic.IList`1<ReFlex.Core.Common.Components.InteractionFrame>)
get_Distance()
set_Distance(System.Single)
get_MinDistance()
set_MinDistance(System.Single)
get_MaxDistance()
set_MaxDistance(System.Single)
get_MinAngle()
set_MinAngle(System.Single)
get_MinConfidence()
set_MinConfidence(System.Int32)
get_MaxConfidence()
set_MaxConfidence(System.Int32)
get_InteractionHistorySize()
set_InteractionHistorySize(System.Int32)
get_NumSmoothingFrames()
set_NumSmoothingFrames(System.Int32)
get_MaxNumEmptyFramesBetween()
set_MaxNumEmptyFramesBetween(System.Int32)
get_TouchMergeDistance2D()
set_TouchMergeDistance2D(System.Single)
get_DepthScale()
set_DepthScale(System.Single)
get_FilterType()
set_FilterType(ReFlex.Core.Interactivity.Util.FilterType)
get_ExtremumTypeCheckNumSamples()
set_ExtremumTypeCheckNumSamples(System.Int32)
get_ExtremumTypeCheckRadius()
set_ExtremumTypeCheckRadius(System.Int32)
get_ExtremumTypeCheckFittingPercentage()
set_ExtremumTypeCheckFittingPercentage(System.Single)
get_ExtremumTypeCheckMethod()
set_ExtremumTypeCheckMethod(ReFlex.Core.Common.Util.ExtremumTypeCheckMethod)
get_PointCloud()
set_PointCloud(ReFlex.Core.Common.Components.PointCloud3)
get_VectorField()
set_VectorField(ReFlex.Core.Common.Components.VectorField2)
get_InputDistance()
Init(ReFlex.Core.Common.Util.ObserverType)
Update()
Dispose()
OnPointcloudChanged(System.Object,ReFlex.Core.Common.Components.PointCloud3)
OnVectorfieldChanged(System.Object,ReFlex.Core.Common.Components.VectorField2)
OnNewInteractions(System.Object,System.Collections.Generic.IList`1<ReFlex.Core.Common.Components.Interaction>)
RemoveClusteredInteractions(System.Collections.Generic.IList`1<ReFlex.Core.Common.Components.Interaction>)