public override Task Process()

in Backend/src/Trackable.TripDetection/Modules/NoiseRemovalModule.cs [57:116]
46 lines of code
12 McCabe index (conditional complexity)

        public override Task<TripDetectionContext> Process(TripDetectionContext input, ILogger logger)
        {
            logger.LogDebugSerialize("Recieved points {0}", input.FilteredOrderedPoints);

            // Filter out points with low accuracy or no datetime stamps 
            var noisePoints = input.FilteredOrderedPoints.Where(p =>
                (p.Accuracy.HasValue && p.Accuracy.Value > this.minimumAccuracy)
                || p.DeviceTimestampUtc == 0);

            var preFilteredPoints = input.FilteredOrderedPoints.Except(noisePoints).ToList();

            logger.LogDebugSerialize("Filtered points based on accuracy or 0 timestamps {0}", preFilteredPoints);

            var filteredPoints = new List<TrackingPoint>();
            for (int i = 0; i < preFilteredPoints.Count - 1; i++)
            {
                if (preFilteredPoints[i].DeviceTimestampUtc != preFilteredPoints[i + 1].DeviceTimestampUtc
                    && (preFilteredPoints[i].Latitude != preFilteredPoints[i + 1].Latitude 
                    || preFilteredPoints[i].Longitude != preFilteredPoints[i + 1].Longitude ))
                {
                    filteredPoints.Add(preFilteredPoints[i]);
                }
            }

            input.FilteredOrderedPoints = filteredPoints;

            logger.LogDebugSerialize("Removed duplicate points {0}", filteredPoints);

            if (filteredPoints.Count < 2)
            {
                logger.LogDebugSerialize("Output few points {0}", filteredPoints);
                return Task.FromResult(input);
            }

            var accelerations = MathUtils.AveragePointAccelerations(filteredPoints);

            var flaggedPointIndeces = new HashSet<int>();
            for (int i = 0; i < accelerations.Count; i++)
            {
                if (accelerations[i] > this.accelerationThreshold)
                {
                    flaggedPointIndeces.Add(i);
                }
            }

            var finalPoints = new List<TrackingPoint>();
            for (int i = 0; i < filteredPoints.Count; i++)
            {
                if (!flaggedPointIndeces.Contains(i))
                {
                    finalPoints.Add(filteredPoints[i]);
                }
            }

            input.FilteredOrderedPoints = finalPoints.OrderBy(p => p.DeviceTimestampUtc).ToList();

            logger.LogDebugSerialize("Output further filtered points {0}", input.FilteredOrderedPoints);

            return Task.FromResult(input);
        }