< 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
0%
Covered lines: 0
Uncovered lines: 212
Coverable lines: 212
Total lines: 400
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 107
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%210%
get_Interactions()0%620%
get_Type()0%620%
set_Type(...)0%3050%
ComputeZeroPlaneDistance()0%620%
UpdateObserver(...)0%2040%
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()0%620%
set_ExtremumTypeCheckNumSamples(...)0%620%
get_ExtremumTypeCheckRadius()0%620%
set_ExtremumTypeCheckRadius(...)0%620%
get_ExtremumTypeCheckFittingPercentage()0%620%
set_ExtremumTypeCheckFittingPercentage(...)0%620%
get_ExtremumTypeCheckMethod()0%620%
set_ExtremumTypeCheckMethod(...)0%620%
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()0%2040%
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;
 033        private float _smoothingDistanceSquared = 64f;
 034        private float _depthScale = 100.0f;
 35
 036        public IList<Interaction> Interactions => _interactions ?? new List<Interaction>();
 37
 38        public ObserverType Type
 39        {
 040            get => _interactionObserver?.Type ?? ObserverType.None;
 41            set
 042            {
 043                switch (value)
 44                {
 45                    case ObserverType.Remote:
 046                        UpdateObserver(new RemoteInteractionProcessor(_service));
 047                        break;
 48                    case ObserverType.MultiTouch:
 049                        UpdateObserver(new MultiInteractionObserver());
 50
 051                        break;
 52                    case ObserverType.SingleTouch:
 053                        UpdateObserver(new SingleInteractionObserver());
 54
 055                        break;
 56                    case ObserverType.None:
 057                        UpdateObserver(new NoInteractionObserver());
 058                        break;
 59                    default:
 060                        throw new ArgumentOutOfRangeException(nameof(value), value, null);
 61                }
 062            }
 63        }
 64
 65        public float ComputeZeroPlaneDistance()
 066        {
 067            if (_interactionObserver == null)
 068                return 0;
 69
 070            return _interactionObserver.CalculateAverageDistance();
 071        }
 72
 73        private void UpdateObserver(IInteractionObserver observer)
 074        {
 075            if (_interactionObserver != null)
 076            {
 077                _interactionObserver.NewInteractions -= OnNewInteractions;
 078                _interactionObserver.InteractionHistoryUpdated -= OnHistoryUpdated;
 079                _performanceAggregator.UnregisterReporter(observer as IPerformanceReporter);
 080            }
 81
 082            if (observer == null)
 083                return;
 84
 085            observer.Distance = _distance;
 086            observer.MinDistance = _minDistance;
 087            observer.MaxDistance = _maxDistance;
 088            observer.MinConfidence = _minConfidence;
 089            observer.MaxConfidence = _maxConfidence;
 090            observer.MinAngle = _minAngle;
 091            observer.PointCloud = _depthImageManager.PointCloud;
 092            observer.VectorField = _depthImageManager.VectorField;
 093            observer.NumSmoothingFrames = _numSmoothFrames;
 094            observer.InteractionHistorySize = _interactionHistorySize;
 095            observer.TouchMergeDistance2D = _smoothingDistanceSquared;
 096            observer.MaxNumEmptyFramesBetween = _maxNumEmptyFramesBetween;
 097            observer.DepthScale = _depthScale;
 098            _interactionObserver = observer;
 99
 0100            _interactionObserver.NewInteractions += OnNewInteractions;
 0101            _interactionObserver.InteractionHistoryUpdated += OnHistoryUpdated;
 0102            _performanceAggregator.RegisterReporter(_interactionObserver as IPerformanceReporter);
 0103        }
 104
 105        private void OnHistoryUpdated(object sender, IList<InteractionFrame> e)
 0106        {
 0107            InteractionHistoryUpdated?.Invoke(this, e);
 0108        }
 109
 110        public float Distance
 111        {
 0112            get => _interactionObserver?.Distance ?? 0;
 113            set
 0114            {
 0115                if (_interactionObserver != null)
 0116                    _interactionObserver.Distance = value;
 117
 0118                _distance = value;
 0119            }
 120        }
 121
 122        public float MinDistance
 123        {
 0124            get => _interactionObserver?.MinDistance ?? 0;
 125            set
 0126            {
 0127                if (_interactionObserver != null)
 0128                    _interactionObserver.MinDistance = value;
 129
 0130                _minDistance = value;
 0131            }
 132        }
 133
 134        public float MaxDistance
 135        {
 0136            get => _interactionObserver?.MaxDistance ?? 0;
 137            set
 0138            {
 0139                if (_interactionObserver != null)
 0140                    _interactionObserver.MaxDistance = value;
 141
 0142                _maxDistance = value;
 0143            }
 144        }
 145
 146        public float MinAngle
 147        {
 0148            get => _interactionObserver?.MinAngle ?? 0;
 149            set
 0150            {
 0151                if (_interactionObserver != null)
 0152                    _interactionObserver.MinAngle = value;
 153
 0154                _minAngle = value;
 0155            }
 156        }
 157
 158        public int MinConfidence
 159        {
 0160            get => (int)(_interactionObserver?.MinConfidence ?? 0);
 161            set
 0162            {
 0163                if (_interactionObserver != null)
 0164                    _interactionObserver.MinConfidence = value;
 165
 0166                _minConfidence = value;
 0167            }
 168        }
 169
 170        public int MaxConfidence
 171        {
 0172            get => (int)(_interactionObserver?.MaxConfidence ?? 0);
 173            set
 0174            {
 0175                if (_interactionObserver != null)
 0176                    _interactionObserver.MaxConfidence = value;
 177
 0178                _maxConfidence = value;
 0179            }
 180        }
 181
 182        public int InteractionHistorySize
 183        {
 0184            get => _interactionObserver?.InteractionHistorySize ?? 0;
 185            set
 0186            {
 0187                if (_interactionObserver != null)
 0188                    _interactionObserver.InteractionHistorySize = value;
 189
 0190                _interactionHistorySize = value;
 0191            }
 192        }
 193
 194        public int NumSmoothingFrames
 195        {
 0196            get => _interactionObserver?.NumSmoothingFrames ?? 0;
 197            set
 0198            {
 0199                if (_interactionObserver != null)
 0200                    _interactionObserver.NumSmoothingFrames = value;
 201
 0202                _numSmoothFrames = value;
 0203            }
 204        }
 205
 206        public int MaxNumEmptyFramesBetween
 207        {
 0208            get => _interactionObserver?.MaxNumEmptyFramesBetween ?? 0;
 209            set
 0210            {
 0211                if (_interactionObserver != null)
 0212                    _interactionObserver.MaxNumEmptyFramesBetween = value;
 213
 0214                _maxNumEmptyFramesBetween = value;
 0215            }
 216        }
 217
 218        public float TouchMergeDistance2D
 219        {
 0220            get => _interactionObserver?.TouchMergeDistance2D ?? 0f;
 221            set
 0222            {
 0223                if (_interactionObserver != null)
 0224                    _interactionObserver.TouchMergeDistance2D = value;
 225
 0226                _smoothingDistanceSquared = value;
 0227            }
 228        }
 229
 230        public float DepthScale
 231        {
 0232            get => _interactionObserver?.DepthScale ?? 0f;
 233            set
 0234            {
 0235                if (_interactionObserver != null)
 0236                    _interactionObserver.DepthScale = value;
 237
 0238                _depthScale = value;
 0239            }
 240        }
 241
 242        public FilterType FilterType {
 0243            get => _interactionObserver?.FilterType ?? FilterType.None;
 244            set
 0245            {
 0246                if (_interactionObserver != null)
 0247                    _interactionObserver.FilterType = value;
 0248            }
 249        }
 250
 251        public int ExtremumTypeCheckNumSamples
 252        {
 0253            get => _interactionObserver?.ExtremumTypeCheckNumSamples ?? 0;
 254            set
 0255            {
 0256                if (_interactionObserver != null)
 0257                    _interactionObserver.ExtremumTypeCheckNumSamples = value;
 0258            }
 259        }
 260
 261        public int ExtremumTypeCheckRadius
 262        {
 0263            get => _interactionObserver?.ExtremumTypeCheckRadius ?? 0;
 264            set
 0265            {
 0266                if (_interactionObserver != null)
 0267                    _interactionObserver.ExtremumTypeCheckRadius = value;
 0268            }
 269        }
 270
 271        public float ExtremumTypeCheckFittingPercentage
 272        {
 0273            get => _interactionObserver?.ExtremumTypeCheckFittingPercentage ?? 0f;
 274            set
 0275            {
 0276                if (_interactionObserver != null)
 0277                    _interactionObserver.ExtremumTypeCheckFittingPercentage = value;
 0278            }
 279        }
 280
 281        public ExtremumTypeCheckMethod ExtremumTypeCheckMethod
 282        {
 0283            get => _interactionObserver?.ExtremumTypeCheckMethod ?? ExtremumTypeCheckMethod.Global;
 284            set
 0285            {
 0286                if (_interactionObserver != null)
 0287                    _interactionObserver.ExtremumTypeCheckMethod = value;
 0288            }
 289        }
 290
 291        public PointCloud3 PointCloud
 292        {
 0293            get => _interactionObserver?.PointCloud;
 0294            set => _interactionObserver.PointCloud = value;
 295        }
 296
 297        public VectorField2 VectorField
 298        {
 0299            get => _interactionObserver?.VectorField;
 0300            set => _interactionObserver.VectorField = value;
 301        }
 302
 0303        public float InputDistance { get; set; }
 304
 0305        public InteractionManager(IDepthImageManager depthImageManager, IRemoteInteractionProcessorService service, IPer
 0306        {
 0307            _depthImageManager = depthImageManager;
 0308            _service = service;
 0309            _performanceAggregator = performanceAggregator;
 310
 0311            depthImageManager.PointcloudFiltered += OnPointcloudChanged;
 0312            depthImageManager.VectorfieldChanged += OnVectorfieldChanged;
 0313        }
 314
 315        public void Init(ObserverType type)
 0316        {
 0317            Type = type;
 0318        }
 319
 320        public async Task<ProcessServiceStatus> Update()
 0321        {
 0322            if (_interactionObserver == null)
 0323                return ProcessServiceStatus.Error;
 324
 0325            return (await _interactionObserver.Update())?.ServiceStatus ?? ProcessServiceStatus.Error;
 0326        }
 327
 328        public event EventHandler<IList<Interaction>> InteractionsUpdated;
 329
 330        public event EventHandler<IList<InteractionFrame>> InteractionHistoryUpdated;
 331
 332        public void Dispose()
 0333        {
 0334            if (_depthImageManager != null)
 0335            {
 0336                _depthImageManager.PointcloudFiltered -= OnPointcloudChanged;
 0337                _depthImageManager.VectorfieldChanged -= OnVectorfieldChanged;
 0338            }
 339
 0340            if (_interactionObserver != null)
 0341            {
 0342                _interactionObserver.NewInteractions -= OnNewInteractions;
 0343                _interactionObserver.InteractionHistoryUpdated -= OnHistoryUpdated;
 344
 0345                _performanceAggregator.UnregisterReporter(_interactionObserver as IPerformanceReporter);
 0346            }
 0347        }
 348
 349        private void OnPointcloudChanged(object sender, PointCloud3 source)
 0350        {
 0351            if (_interactionObserver != null)
 0352                _interactionObserver.PointCloud = source;
 0353        }
 354
 355        private void OnVectorfieldChanged(object sender, VectorField2 source)
 0356        {
 0357            if (_interactionObserver != null)
 0358                _interactionObserver.VectorField = source;
 0359        }
 360
 361        private void OnNewInteractions(object sender, IList<Interaction> interactions)
 0362        {
 0363            lock (interactions)
 0364            {
 0365                var copy = interactions.Select(interaction => new Interaction(interaction)).ToList();
 0366                _interactions = RemoveClusteredInteractions(copy);
 0367            }
 368
 0369            InteractionsUpdated?.Invoke(this, _interactions);
 0370        }
 371
 372        private IList<Interaction> RemoveClusteredInteractions(IList<Interaction> rawInteractions)
 0373        {
 0374            var filteredCopy = new List<Interaction>();
 375
 0376            for (var i = 0; i < rawInteractions.Count; i++)
 0377            {
 0378                var currPt = rawInteractions[i];
 0379                var distances = filteredCopy.Select(inter => Point3.Squared2DDistance(inter.Position, currPt.Position)).
 380
 0381                var addPoint = true;
 382
 0383                for (var j = 0; j < distances.Count; j++)
 0384                {
 0385                    var distance = distances[j];
 0386                    if (distance < InputDistance)
 0387                    {
 0388                        addPoint = false;
 0389                        break;
 390                    }
 0391                }
 0392                if (addPoint)
 0393                    filteredCopy.Add(currPt);
 0394            }
 0395            return filteredCopy;
 0396        }
 397
 398
 399    }
 400}
Generated by: ReportGenerator 5.4.5.0
4/15/2025 - 11:07:02 AM
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>)