Ejemplo n.º 1
0
        // Total Distance
        public static float CalculateTotalDistance(IList <MovementSupervised> movementSupervisedCollection)
        {
            movementSupervisedCollection = movementSupervisedCollection.OrderBy(m => m.Time).ToList();

            MovementSupervised lastMovementSupervised = movementSupervisedCollection.FirstOrDefault();
            float distance;
            float totalDistance = 0;

            for (int i = 0; i < movementSupervisedCollection.Count; i++)
            {
                var movementSupervised = movementSupervisedCollection[i];

                if (movementSupervised.State == (int)MovementState.DragSingleBegin || movementSupervised.State == (int)MovementState.MakeGroupBegin || movementSupervised.State == (int)MovementState.DragGroupBegin)
                {
                    lastMovementSupervised = null;
                }
                else if (movementSupervised.State == (int)MovementState.DragSingleMove || movementSupervised.State == (int)MovementState.DragSingleEnd || movementSupervised.State == (int)MovementState.MakeGroupMove || movementSupervised.State == (int)MovementState.MakeGroupEnd || movementSupervised.State == (int)MovementState.DragGroupMove || movementSupervised.State == (int)MovementState.DragSingleEnd)
                {
                    if (!movementSupervised.IsAbnormal || !lastMovementSupervised.IsAbnormal)
                    {
                        distance       = (float)(Math.Sqrt(Math.Pow(lastMovementSupervised.XPosition - movementSupervised.XPosition, 2) + Math.Pow(lastMovementSupervised.YPosition - movementSupervised.YPosition, 2)));
                        totalDistance += distance;
                    }
                }
                lastMovementSupervised = movementSupervised;
            }

            return((float)Math.Round(totalDistance, 2));
        }
Ejemplo n.º 2
0
        // DD Count
        public static int CalculateAbnormalTrajectoryCount(IList <MovementSupervised> movementSupervisedCollection)
        {
            movementSupervisedCollection = movementSupervisedCollection.OrderBy(m => m.Time).ToList();
            MovementSupervised movementSupervised = movementSupervisedCollection.FirstOrDefault();

            int  count      = 0;
            bool isAbnormal = false;

            for (int i = 0; i < movementSupervisedCollection.Count; i++)
            {
                movementSupervised = movementSupervisedCollection[i];

                if (movementSupervised.State == (int)MovementState.DragSingleBegin || movementSupervised.State == (int)MovementState.DragGroupBegin || movementSupervised.State == (int)MovementState.MakeGroupBegin)
                {
                    isAbnormal = false;
                }

                if (movementSupervised.IsAbnormal && isAbnormal == false)
                {
                    isAbnormal = true;
                    count++;
                }
                else if (!movementSupervised.IsAbnormal && isAbnormal == true)
                {
                    isAbnormal = false;
                }
            }

            return(count);
        }
Ejemplo n.º 3
0
        // Grouping DD Count
        public static int CalculateGroupingDDCount(IList <MovementSupervised> movementSupervisedCollection)
        {
            movementSupervisedCollection = movementSupervisedCollection.OrderBy(m => m.Time).ToList();
            MovementSupervised movementSupervised = movementSupervisedCollection.FirstOrDefault();

            int  count       = 0;
            bool isOperating = false;

            for (int i = 0; i < movementSupervisedCollection.Count; i++)
            {
                movementSupervised = movementSupervisedCollection[i];

                if (movementSupervised.State == (int)MovementState.MakeGroupBegin)
                {
                    isOperating = true;
                }
                else if (movementSupervised.State == (int)MovementState.MakeGroupMove)
                {
                    continue;
                }
                else if (movementSupervised.State == (int)MovementState.MakeGroupEnd)
                {
                    if (isOperating)
                    {
                        count++;
                        isOperating = false;
                    }
                }
            }

            return(count);
        }
Ejemplo n.º 4
0
        // DD First Time
        public static float CalculateDDFirstTime(IList <MovementSupervised> movementSupervisedCollection)
        {
            movementSupervisedCollection = movementSupervisedCollection.OrderBy(m => m.Time).ToList();

            MovementSupervised movementSupervised = movementSupervisedCollection.FirstOrDefault();

            return(movementSupervised == null ? 0 : movementSupervised.Time);
        }
Ejemplo n.º 5
0
        // U Turn Vertical Count
        public static int CalculateUTurnVerticalCount(IList <MovementSupervised> movementSupervisedCollection)
        {
            movementSupervisedCollection = movementSupervisedCollection.OrderBy(m => m.Time).ToList();
            MovementSupervised lastMovementSupervised = movementSupervisedCollection.FirstOrDefault();

            int  count = 0;
            bool isToPositiveDirection        = true;
            bool isDirectionHasBeenCalculated = false;

            for (int i = 0; i < movementSupervisedCollection.Count; i++)
            {
                var movementSupervised = movementSupervisedCollection[i];

                if (movementSupervised.State == (int)MovementState.DragSingleBegin || movementSupervised.State == (int)MovementState.DragGroupBegin || movementSupervised.IsAbnormal)
                {
                    lastMovementSupervised       = movementSupervised;
                    isDirectionHasBeenCalculated = false;
                }
                else if (movementSupervised.State == (int)MovementState.DragSingleMove || movementSupervised.State == (int)MovementState.DragSingleEnd || movementSupervised.State == (int)MovementState.DragGroupMove || movementSupervised.State == (int)MovementState.DragGroupEnd)
                {
                    if (!isDirectionHasBeenCalculated)
                    {
                        if (movementSupervised.YPosition - lastMovementSupervised.YPosition != 0)
                        {
                            isDirectionHasBeenCalculated = true;

                            isToPositiveDirection = movementSupervised.YPosition - lastMovementSupervised.YPosition > 0 ? true : false;

                            lastMovementSupervised = movementSupervised;
                        }
                    }
                    else
                    {
                        if (movementSupervised.YPosition - lastMovementSupervised.YPosition > 0 && !isToPositiveDirection)
                        {
                            count++;
                            isToPositiveDirection = true;
                        }
                        else if (movementSupervised.YPosition - lastMovementSupervised.YPosition < 0 && isToPositiveDirection)
                        {
                            count++;
                            isToPositiveDirection = false;
                        }

                        lastMovementSupervised = movementSupervised;
                    }
                }
            }

            return(count);
        }
Ejemplo n.º 6
0
        // DD Speed MIN
        public static float CalculateDDSpeedMIN(IList <MovementSupervised> movementSupervisedCollection)
        {
            movementSupervisedCollection = movementSupervisedCollection.OrderBy(m => m.Time).ToList();

            MovementSupervised lastMovementSupervised = movementSupervisedCollection.FirstOrDefault();
            float distance;
            float DDSpeed    = 0;
            float DDSpeedMIN = 0;
            bool  isFirstCalculatedDDSpeed = true;

            for (int i = 0; i < movementSupervisedCollection.Count; i++)
            {
                var movementSupervised = movementSupervisedCollection[i];

                if (movementSupervised.State == (int)MovementState.DragSingleBegin || movementSupervised.State == (int)MovementState.MakeGroupBegin || movementSupervised.State == (int)MovementState.DragGroupBegin)
                {
                    lastMovementSupervised = movementSupervised;
                }
                else if (movementSupervised.State == (int)MovementState.DragSingleMove || movementSupervised.State == (int)MovementState.DragSingleEnd || movementSupervised.State == (int)MovementState.MakeGroupMove || movementSupervised.State == (int)MovementState.MakeGroupEnd || movementSupervised.State == (int)MovementState.DragGroupMove || movementSupervised.State == (int)MovementState.DragSingleEnd)
                {
                    if (movementSupervised.Time == lastMovementSupervised.Time)
                    {
                        lastMovementSupervised = movementSupervised;
                        continue;
                    }

                    if (!movementSupervised.IsAbnormal || !lastMovementSupervised.IsAbnormal)
                    {
                        distance = (float)(Math.Sqrt(Math.Pow(lastMovementSupervised.XPosition - movementSupervised.XPosition, 2) + Math.Pow(lastMovementSupervised.YPosition - movementSupervised.YPosition, 2)));
                        DDSpeed  = (float)(distance / ((movementSupervised.Time - lastMovementSupervised.Time) / 1000.0));

                        if (isFirstCalculatedDDSpeed)
                        {
                            DDSpeedMIN = DDSpeed;
                            isFirstCalculatedDDSpeed = false;
                        }
                        else
                        {
                            if (DDSpeed < DDSpeedMIN)
                            {
                                DDSpeedMIN = DDSpeed;
                            }
                        }
                    }

                    lastMovementSupervised = movementSupervised;
                }
            }

            return((float)Math.Round(DDSpeedMIN, 2));
        }
Ejemplo n.º 7
0
        // D&D Process MIN
        public static float CalculateDDProcessMIN(IList <MovementSupervised> movementSupervisedCollection)
        {
            movementSupervisedCollection = movementSupervisedCollection.OrderBy(m => m.Time).ToList();

            MovementSupervised lastMovementSupervised = null;
            int  differTime    = 0;
            int  differTimeMIN = 0;
            bool isFirstCalculatedDDProcess = true;

            for (int i = 0; i < movementSupervisedCollection.Count; i++)
            {
                var movementSupervised = movementSupervisedCollection[i];
                if (movementSupervised.State == (int)MovementState.DragSingleBegin || movementSupervised.State == (int)MovementState.DragGroupBegin)
                {
                    differTime             = 0;
                    lastMovementSupervised = null;
                }
                else if (movementSupervised.State == (int)MovementState.DragSingleMove || movementSupervised.State == (int)MovementState.DragGroupMove)
                {
                    if (!movementSupervised.IsAbnormal || !lastMovementSupervised.IsAbnormal)
                    {
                        differTime += (movementSupervised.Time - lastMovementSupervised.Time);
                    }
                }
                else if (movementSupervised.State == (int)MovementState.DragSingleEnd || movementSupervised.State == (int)MovementState.DragGroupEnd)
                {
                    if (!movementSupervised.IsAbnormal || !lastMovementSupervised.IsAbnormal)
                    {
                        differTime += (movementSupervised.Time - lastMovementSupervised.Time);
                    }

                    if (isFirstCalculatedDDProcess)
                    {
                        differTimeMIN = differTime;
                        isFirstCalculatedDDProcess = false;
                    }
                    else
                    {
                        if (differTime < differTimeMIN)
                        {
                            differTimeMIN = differTime;
                        }
                    }
                }

                lastMovementSupervised = movementSupervised;
            }

            return((float)differTimeMIN);
        }
Ejemplo n.º 8
0
        public IList <MovementSupervised> SuperviseByAccelerationAndForce()
        {
            var deviceAccelerationCombinedCollection         = CombineDeviceAcceleration(deviceAccelerationCollection);
            var deviceAccelerationCombinedFilteredCollection = FilterDeviceAccelerationCombinedCollection(deviceAccelerationCombinedCollection);

            // Build movementSupervised list
            var movementSupervisedCollection = new List <MovementSupervised>();

            for (int i = 0; i < movementCollection.Count; i++)
            {
                var movement = movementCollection[i];

                var movementSupervised = new MovementSupervised
                {
                    ID             = movement.ID,
                    AnswerRecordID = movement.AnswerRecordID,
                    Index          = movement.Index,
                    Time           = movement.Time,
                    State          = movement.State,
                    TargetElement  = movement.TargetElement,
                    XPosition      = movement.XPosition,
                    YPosition      = movement.YPosition,
                    Force          = movement.Force,

                    IsAbnormal = false,
                };

                movementSupervisedCollection.Add(movementSupervised);
            }

            for (int i = 0; i < deviceAccelerationCombinedFilteredCollection.Count; i++)
            {
                var deviceAccelerationCombinedFiltered = deviceAccelerationCombinedFilteredCollection[i];
                if (deviceAccelerationCombinedFiltered.Acceleration >= ThACC)
                {
                    var selectedMovementSupervisedIndex = FindMovementIndexByTime(movementSupervisedCollection, deviceAccelerationCombinedFiltered.Time);
                    var movementSupervised = movementSupervisedCollection[selectedMovementSupervisedIndex];

                    if (movementSupervised.Force > ThFOC)
                    {
                        movementSupervised.IsAbnormal = true;
                    }
                }
            }
            return(movementSupervisedCollection);
        }
Ejemplo n.º 9
0
        // D&D Process Average
        public static float CalculateDDProcessAVG(IList <MovementSupervised> movementSupervisedCollection)
        {
            movementSupervisedCollection = movementSupervisedCollection.OrderBy(m => m.Time).ToList();

            MovementSupervised lastMovementSupervised = null;
            int totalTime = 0;
            int count     = 0;

            for (int i = 0; i < movementSupervisedCollection.Count; i++)
            {
                var movementSupervised = movementSupervisedCollection[i];
                if (movementSupervised.State == (int)MovementState.DragSingleBegin || movementSupervised.State == (int)MovementState.DragGroupBegin)
                {
                    lastMovementSupervised = null;
                }
                else if (movementSupervised.State == (int)MovementState.DragSingleMove || movementSupervised.State == (int)MovementState.DragGroupMove)
                {
                    if (!movementSupervised.IsAbnormal || !lastMovementSupervised.IsAbnormal)
                    {
                        totalTime += (movementSupervised.Time - lastMovementSupervised.Time);
                    }
                }
                else if (movementSupervised.State == (int)MovementState.DragSingleEnd || movementSupervised.State == (int)MovementState.DragGroupEnd)
                {
                    if (!movementSupervised.IsAbnormal || !lastMovementSupervised.IsAbnormal)
                    {
                        totalTime += (movementSupervised.Time - lastMovementSupervised.Time);
                    }
                    count++;
                }

                lastMovementSupervised = movementSupervised;
            }

            return((float)totalTime / count);
        }