Example #1
0
    public void UpdateSelection(HandPositions handPositions)
    {
        left    = camera.WorldToScreenPoint(handPositions.left);
        left.y  = camera.pixelHeight - left.y;
        right   = camera.WorldToScreenPoint(handPositions.right);
        right.y = camera.pixelHeight - right.y;

        foreach (ClothingButton button in buttons)
        {
            if (button.Hover(left) || button.Hover(right))
            {
                button.currentSelectionTime += Time.deltaTime;
            }
            else
            {
                button.currentSelectionTime = 0.0F;
            }

            //check if user hovered long enough to select
            if (button.currentSelectionTime > selectionThreshold)
            {
                userEvent = true;
                currentSelections.Add(button);
            }
        }
    }
Example #2
0
        public void SetLeds(HandPositions hand, uint[] positions, LF10LedColor color)
        {
            try
            {
                int leds = 0;

                foreach (uint position in positions)
                {
                    leds += GetLed(hand, position);
                }

                leds += (int)color;

                base.setDeviceProperty(PropertyType.FG_LEDS, leds);
            }
            catch (Exception e)
            {
                Trace.TraceError(e.ToString());
            }
        }
Example #3
0
        public int GetLed(HandPositions hand, uint position)
        {
            int led = 0;

            switch (hand)
            {
            case HandPositions.Left:
                switch (position)
                {
                case 1:
                    led = (int)LF10MultiLed.LEFT_LITTLE;
                    break;

                case 2:
                    led = (int)LF10MultiLed.LEFT_RING;
                    break;

                case 3:
                    led = (int)LF10MultiLed.LEFT_MIDDLE;
                    break;

                case 4:
                    led = (int)LF10MultiLed.LEFT_INDEX;
                    break;

                default:
                    break;
                }
                break;

            case HandPositions.Right:
                switch (position)
                {
                case 1:
                    led = (int)LF10MultiLed.RIGHT_INDEX;
                    break;

                case 2:
                    led = (int)LF10MultiLed.RIGHT_MIDDLE;
                    break;

                case 3:
                    led = (int)LF10MultiLed.RIGHT_RING;
                    break;

                case 4:
                    led = (int)LF10MultiLed.RIGHT_LITTLE;
                    break;

                default:
                    break;
                }
                break;

            case HandPositions.Thumbs:
                switch (position)
                {
                case 1:
                    led = (int)LF10MultiLed.LEFT_THUMB;
                    break;

                case 2:
                    led = (int)LF10MultiLed.RIGHT_THUMB;
                    break;

                default:
                    break;
                }
                break;

            case HandPositions.Unknown:
                break;

            default:
                break;
            }

            return(led);
        }
Example #4
0
        /// <summary>
        /// Validates the capturing sequence.
        /// </summary>
        /// <param name="finger">The finger.</param>
        /// <param name="activeSequence">The active sequence.</param>
        /// <param name="currentStep">The current step.</param>
        /// <returns></returns>
        public bool ValidateCapturingSequence(MainForm.SegmentedFingerprintImage[] segments, ActiveSequence activeSequence, int currentStep, bool fakeDetected = false)
        {
            bool valid = false;

            this.validError = string.Empty;


            if (fakeDetected)
            {
                valid           = false;
                this.validError = "Finger is possible FAKE or misplaced";
                return(valid);
            }

            HandPositions hand = segments[0].fpSeg.Hand;


            switch (activeSequence)
            {
            case ActiveSequence.OneRolled:
                valid = true;
                break;

            case ActiveSequence.FourTwoFour:
                #region Check FourTwoFour sequence
                if (currentStep == 1)
                {
                    if (hand == HandPositions.Left)
                    {
                        if (segments.Length == 4)
                        {
                            valid = true;
                        }
                        else
                        {
                            this.validError = "Four finger expected!";
                        }
                    }
                    else
                    {
                        this.validError = "Left Hand expected for this Sequence!";
                    }
                }
                else if (currentStep == 2)
                {
                    if (hand == HandPositions.Thumbs)
                    {
                        valid = true;
                    }
                    else
                    {
                        this.validError = "Thumbs expected for this Sequence!";
                    }
                }
                else if (currentStep == 3)
                {
                    if (hand == HandPositions.Right)
                    {
                        if (segments.Length == 4)
                        {
                            valid = true;
                        }
                        else
                        {
                            this.validError = "Four finger expected!";
                        }
                    }
                    else
                    {
                        this.validError = "Right Hand expected for this Sequence!";
                    }
                }
                #endregion
                break;

            case ActiveSequence.FourFourTwo:
                #region Check FourFourTwo sequence
                if (currentStep == 1)
                {
                    if (hand == HandPositions.Left)
                    {
                        if (segments.Length == 4)
                        {
                            valid = true;
                        }
                        else
                        {
                            this.validError = "Four finger expected!";
                        }
                    }
                    else
                    {
                        this.validError = "Left Hand expected for this Sequence!";
                    }
                }
                else if (currentStep == 2)
                {
                    if (hand == HandPositions.Right)
                    {
                        if (segments.Length == 4)
                        {
                            valid = true;
                        }
                        else
                        {
                            this.validError = "Four finger expected!";
                        }
                    }
                    else
                    {
                        this.validError = "Right Hand expected for this Sequence!";
                    }
                }
                else if (currentStep == 3)
                {
                    if (hand == HandPositions.Thumbs)
                    {
                        valid = true;
                    }
                    else
                    {
                        this.validError = "Thumbs expected for this Sequence!";
                    }
                }
                #endregion
                break;

            default:
                this.validError = "Capturing failed, please try it again.";
                break;
            }
            if (/*string.IsNullOrEmpty(this.validError)*/ valid)
            {
                this.validError = "Validation Error!";
            }
            return(valid);
        }
Example #5
0
        /// <summary>
        /// Identifies the finger by Fourprintsegmentation data.
        /// </summary>
        /// <param name="handPositions">The hand positions.</param>
        /// <param name="fingerPosition">The finger position.</param>
        public void IdentifyFinger(HandPositions handPositions, uint fingerPosition)
        {
            this.CurrentFingerName = string.Empty;
            this.CurrentFingerType = SegmentType.Unknown;
            switch (handPositions)
            {
            case HandPositions.Left:
                this.CurrentHand = SegmentType.LeftFourPrint;
                switch (fingerPosition)
                {
                case 1:
                    this.CurrentFingerName = handPositions.ToString() + " Little";
                    this.CurrentFingerType = SegmentType.LL;
                    break;

                case 2:
                    this.CurrentFingerName = handPositions.ToString() + " Ring";
                    this.CurrentFingerType = SegmentType.LR;
                    break;

                case 3:
                    this.CurrentFingerName = handPositions.ToString() + " Middle";
                    this.CurrentFingerType = SegmentType.LM;
                    break;

                case 4:
                    this.CurrentFingerName = handPositions.ToString() + " Index";
                    this.CurrentFingerType = SegmentType.LI;
                    break;

                default:
                    break;
                }
                break;

            case HandPositions.Right:
                this.CurrentHand = SegmentType.RightFourPrint;
                switch (fingerPosition)
                {
                case 1:
                    this.CurrentFingerName = handPositions.ToString() + " Index";
                    this.CurrentFingerType = SegmentType.RI;
                    break;

                case 2:
                    this.CurrentFingerName = handPositions.ToString() + " Middle";
                    this.CurrentFingerType = SegmentType.RM;
                    break;

                case 3:
                    this.CurrentFingerName = handPositions.ToString() + " Ring";
                    this.CurrentFingerType = SegmentType.RR;
                    break;

                case 4:
                    this.CurrentFingerName = handPositions.ToString() + " Little";
                    this.CurrentFingerType = SegmentType.RL;
                    break;

                default:
                    break;
                }
                break;

            case HandPositions.Thumbs:
                this.CurrentHand = SegmentType.Thumbs;
                switch (fingerPosition)
                {
                case 1:
                    this.CurrentFingerName = "Left Thumb";
                    this.CurrentFingerType = SegmentType.LT;
                    break;

                case 2:
                    this.CurrentFingerName = "Right Thumb";
                    this.CurrentFingerType = SegmentType.RT;
                    break;

                default:
                    break;
                }
                break;

            case HandPositions.Unknown:

                break;

            default:
                break;
            }
        }
	public void UpdateSelection (HandPositions handPositions) {
		left = camera.WorldToScreenPoint(handPositions.left);
		left.y = camera.pixelHeight-left.y;
		right = camera.WorldToScreenPoint(handPositions.right);
		right.y = camera.pixelHeight-right.y;
		
		foreach (ClothingButton button in buttons) {
			if (button.Hover(left) || button.Hover(right)) {
				button.currentSelectionTime += Time.deltaTime;
			} else {
				button.currentSelectionTime = 0.0F;
			}
			
			//check if user hovered long enough to select
			if (button.currentSelectionTime > selectionThreshold) {
				userEvent = true;
				currentSelections.Add(button);
			}
		}
	}
        public IEnumerable <GuitarMessage> GetByDifficulty(GuitarDifficulty diff)
        {
            var ret = new List <GuitarMessage>();

            foreach (var messageType in GetAllMessageTypes())
            {
                switch (messageType)
                {
                case GuitarMessageType.GuitarHandPosition:
                    ret.AddRange(HandPositions.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarChordName:
                    ret.AddRange(ChordNames.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarTextEvent:
                    ret.AddRange(TextEvents.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarTrainer:
                    ret.AddRange(Trainers.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarChordStrum:
                    ret.AddRange(ChordStrums.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarChord:
                    ret.AddRange(Chords.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarNote:
                    ret.AddRange(Notes.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarPowerup:
                    ret.AddRange(Powerups.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarSolo:
                    ret.AddRange(Solos.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarTempo:
                    ret.AddRange(Tempos.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarTimeSignature:
                    ret.AddRange(TimeSignatures.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarArpeggio:
                    ret.AddRange(Arpeggios.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarBigRockEnding:
                    ret.AddRange(BigRockEndings.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarBigRockEndingSubMessage:

                    break;

                case GuitarMessageType.GuitarSingleStringTremelo:
                    ret.AddRange(SingleStringTremelos.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarMultiStringTremelo:
                    ret.AddRange(MultiStringTremelos.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarSlide:
                    ret.AddRange(Slides.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                case GuitarMessageType.GuitarHammeron:
                    ret.AddRange(Hammerons.Where(x => diff.HasFlag(x.Difficulty)));
                    break;

                default:
                    ("unknown message: " + messageType).OutputDebug();
                    break;
                }
            }

            return(ret);
        }