public IDisposable Subscribe(ReactiveSpace spaceListener)
        {
            CompositeDisposable subscriptions = new CompositeDisposable();
            subscriptions.Add(spaceListener
                                .LockedHands()
                                .ObserveOn(UI)
                                .Subscribe(o =>
                                {
                                    HandsCount++;
                                }));

            subscriptions.Add(spaceListener
                                .LockedHands()
                                .Select(o =>
                                        o
                                        .ObserveOn(UI)
                                        .Subscribe(oo =>
                                        {
                                        }, () =>
                                        {
                                            HandsCount--;
                                        }))
                                .Subscribe());
            subscriptions.Add(SubscribeCore(spaceListener));
            subscriptions.Add(Disposable.Create(()=>HandsCount = 0));
            return subscriptions;
        }
        protected override IDisposable SubscribeCore(ReactiveSpace spaceListener)
        {
            CompositeDisposable subscriptions = new CompositeDisposable();

            subscriptions.Add(spaceListener
                .LockedHands()
                .ObserveOn(UI)
                .SelectMany(h => h
                                .Select(hh => new
                                {
                                    Group = h,
                                    Hand = hh
                                }))
                .Subscribe(h =>
                {
                    var diff = 1000 + (h.Hand.PalmPosition.y - h.Group.Key.PalmPosition.y);
                    var bin = (int)(diff / MinInterval);
                    if(bin < PreviousBin)
                    {
                        if(OnMoveDown != null)
                            OnMoveDown();
                    }
                    if(bin > PreviousBin)
                    {
                        if(OnMoveUp != null)
                            OnMoveUp();
                    }
                    PreviousBin = bin;
                }));

            return subscriptions;
        }
        public override IDisposable Subscribe(ReactiveSpace space)
        {
            return space
                    .ReactiveListener
                    .Gestures()
                    .Where(g => g.Key.Type == _Type)
                    .SelectMany(g => g.ToList().Select(l => new
                    {
                        Key = g.Key,
                        Gestures = l
                    }))
                    .BufferUntilCalm(TimeSpan.FromMilliseconds(200))
                    .Where(b => b.Count > 0)
                    .Subscribe(gs =>
                    {
                        var g = gs[0];

                        float speed = g.Gestures.Where(gg => gg.Pointables.Count > 0)
                                        .Average(gg => gg.Pointables[0].TipVelocity.Magnitude);

                        //Diviser par le nbr de frame a la place de la duration
                        var stop = g.Gestures.Last();
                        var orientation = new Vector(GetDelta(g.Gestures, p => p.x),
                                                      GetDelta(g.Gestures, p => p.y),
                                                     GetDelta(g.Gestures, p => p.z));
                        var size = orientation.Magnitude;
                        orientation = Normalize(orientation);

                        var detected = new LeapGestureViewModel(_Type)
                        {
                            Duration = TimeSpan.FromSeconds(stop.DurationSeconds),
                            Orientation = orientation,
                            FingersCount = gs.SelectMany(gg => gg.Gestures).SelectMany(gg => gg.Pointables).Select(i => i.Id).Distinct().Count(),
                            Speed = speed,
                            Size = size
                        };

                        if(detected.Speed > MinSpeed)
                            OnMatch(detected, 1.0);
                    });
        }
Esempio n. 4
0
 private IDisposable Subscribe(ReactiveSpace reactiveSpace)
 {
     return null;
 }
        protected override IDisposable SubscribeCore(ReactiveSpace spaceListener)
        {
            var deselectWhenUnlocked =
                       spaceListener.IsLocked()
                        .ObserveOn(UI)
                        .Subscribe(isLocked =>
                        {
                            if(!isLocked)
                                ClearCurrent();
                        });
            var updatePosition = spaceListener
                        .LockedHands()
                        .ObserveOn(UI)
                        .Select(g => new
                        {
                            Group = g,
                            CenterPosition = g.Key.PalmPosition
                        })
                        .SelectMany(g =>
                            g
                            .Group
                            .Select(p => new
                            {
                                Position = p,
                                GroupContext = g
                            }))
                        .Subscribe((hand) =>
                        {
                            var offset = hand.Position.PalmPosition.To2D() - hand.GroupContext.CenterPosition.To2D();
                            if(-ZoneHeight/2f <  offset.y &&
                                offset.y < ZoneHeight / 2f &&
                               -ZoneHeight/2f < offset.x &&
                                offset.x < ZoneHeight / 2f)
                                GoTo(Center);

                            if(-ZoneHeight / 2f < offset.y &&
                                offset.y < ZoneHeight / 2f)
                            {
                                if(-ZoneHeight / 2f >= offset.x)
                                {
                                    GoTo(Left);
                                }
                                if(offset.x >= ZoneHeight / 2f)
                                {
                                    GoTo(Right);
                                }
                            }

                            if(-ZoneHeight / 2f < offset.x &&
                                offset.x < ZoneHeight / 2f)
                            {
                                if(-ZoneHeight / 2f >= offset.y)
                                {
                                    GoTo(Down);
                                }
                                if(offset.y >= ZoneHeight / 2f)
                                {
                                    GoTo(Up);
                                }
                            }
                        });

            CompositeDisposable subscriptions = new CompositeDisposable();
            subscriptions.Add(deselectWhenUnlocked);
            subscriptions.Add(updatePosition);
            subscriptions.Add(Disposable.Create(ClearCurrent));
            return subscriptions;
        }
        protected override IDisposable SubscribeCore(ReactiveSpace spaceListener)
        {
            return spaceListener
                .LockedHands()
                .SelectMany(l => l)
                .Where(h => Math.Abs(h.PalmVelocity.y) > VelocityThreshold || Math.Abs(h.PalmVelocity.x) > VelocityThreshold)
                .Sample(MinInterval)
                .ObserveOn(UI)
                .Subscribe(h =>
                {
                    if(OnClicked != null)
                    {
                        LastSide = "Center";
                        OnClicked();
                    }

                    if(Math.Abs(h.PalmVelocity.y) > VelocityThreshold)
                    {
                        var isDown = h.PalmVelocity.y < 0.0;
                        var upOrDown = isDown ? OnDown : OnUp;
                        var side = isDown ? "Down" : "Up";
                        if(upOrDown != null)
                        {
                            LastSide = side;
                            upOrDown();
                        }
                    }
                    else
                    {
                        var isLeft = h.PalmVelocity.x < 0.0;
                        var leftOrRight = isLeft ? OnLeft : OnRight;
                        var side = isLeft ? "Left" : "Right";
                        if(leftOrRight != null)
                        {
                            LastSide = side;
                            leftOrRight();
                        }
                    }
                });
        }
 protected override IDisposable SubscribeCore(ReactiveSpace spaceListener)
 {
     return
         spaceListener.LockedHands()
         .ObserveOn(UI)
         .Select(g => new
         {
             Group = g,
             StartValue = Value,
             StartHeight = g.Key.PalmPosition.y
         })
         .SelectMany(g =>
             g
             .Group
             .Select(p => new
             {
                 Position = p,
                 GroupContext = g
             }))
         .Subscribe((hand) =>
         {
             double heightRange = 150.0;
             var maxHeight = hand.GroupContext.StartHeight + heightRange * ((MaxValue - hand.GroupContext.StartValue) / (MaxValue - MinValue));
             var minHeight = maxHeight - heightRange;
             double height = hand.Position.PalmPosition.y;
             height = Math.Max(minHeight, height);
             height = Math.Min(maxHeight, height);
             Value = Helper.Map(height, minHeight, maxHeight, MinValue, MaxValue);
         });
 }
 public virtual IDisposable Subscribe(ReactiveSpace space)
 {
     return Disposable.Empty;
 }
 protected virtual IDisposable SubscribeCore(ReactiveSpace spaceListener)
 {
     return Disposable.Empty;
 }
Esempio n. 10
0
        private void Subscribe(ReactiveSpace reactiveSpace)
        {
            var fps = reactiveSpace.ReactiveListener.Frames()
                    .Timestamp()
                    .Buffer(2)
                    .ObserveOn(main.UI)
                    .Subscribe(o =>
                    {
                        var seconds = (o[1].Timestamp - o[0].Timestamp).TotalSeconds;
                        FPS = (int)(1.0 / seconds);
                    });

            var fingerCount = reactiveSpace.ReactiveListener.FingersMoves()
                    .ObserveOn(main.UI)
                    .Subscribe(o =>
                    {
                        FingerCount++;
                    });
            _Subscriptions.Add(fingerCount);

            fingerCount = reactiveSpace.ReactiveListener
                    .FingersMoves()
                    .Select(c => c.ObserveOn(main.UI).Subscribe(cc =>
                    {

                    }, () =>
                    {
                        FingerCount--;
                    }))
                    .Subscribe();
            _Subscriptions.Add(fingerCount);

            _Subscriptions.Add(fps);
        }
Esempio n. 11
0
        private void Subscribe(ReactiveSpace spaceListener)
        {
            var minimized =
                spaceListener
                .ReactiveListener
                .FingersMoves()
                .SelectMany(m => m)
                .ThrottleWithDefault(TimeSpan.FromSeconds(1))
                .ObserveOn(UI)
                .Subscribe(b =>
                {
                    if(!ShowConfig)
                    {
                        State = MainViewState.Minimized;
                    }
                });

            //var maximize =
            //				spaceListener
            //				.ReactiveListener
            //				.Gestures
            //				.Where(g => g.Key.Type == Gesture.GestureType.TYPECIRCLE)
            //				.SelectMany(g => g.ToList().Select(l => new
            //													{
            //														Key = g.Key,
            //														Values = l
            //													}))
            //				.Buffer(() => spaceListener.ReactiveListener.Gestures.SelectMany(g => g).OnlyTimeout(TimeSpan.FromMilliseconds(500)))
            //				.Where(b => b.Count > 0)
            //				.Take(1)
            //				.Repeat()
            //				.ObserveOn(UI)
            //				.Subscribe(l =>
            //				{
            //					var distinct = l.SelectMany(oo => oo.Values.SelectMany(o => o.Pointables)).Select(p => p.Id).Distinct().Count();
            //					State = MainViewState.Navigating;
            //				});

            var maximize =
                        spaceListener
                        .LockedHands()
                        .SelectMany(h => h)
                        .ObserveOn(UI)
                        .Subscribe(h =>
                        {
                            if(State == MainViewState.Minimized)
                                State = MainViewState.Navigating;
                        });

            var lockedSubs =
                spaceListener
                .IsLocked()
                .ObserveOn(UI)
                .CombineLatest(Helper.PropertyChanged(this, () => this.State), (l, s) => new
                {
                    Locked = l,
                    State = s
                })
                .Where(o => o.State != MainViewState.Minimized)
                .Subscribe(o =>
                {
                    State = o.Locked ? MainViewState.Locked : MainViewState.Navigating;
                });
            _Subscriptions.Add(lockedSubs);
            _Subscriptions.Add(maximize);
            _Subscriptions.Add(minimized);
        }
Esempio n. 12
0
        public MainViewModel(ReactiveSpace spaceListener)
        {
            _ProgListener = new ForegroundProgramListener();

            _ProgListener.ForegroundProcess
                        .ObserveOn(UI)
                        .Subscribe(pid =>
                        {
                            if(pid != _CurrentPid)
                            {
                                using(var p = Process.GetProcessById(pid))
                                {
                                    CurrentProgram = p.ProcessName;
                                    var tile = Tiles.FirstOrDefault(t => t.BelongsToFastContext(p.ProcessName));
                                    if(tile != null)
                                        CurrentTile = tile;
                                }
                            }
                        });

            this.State = MainViewState.Navigating;
            this._SpaceListener = spaceListener;
            this._Tiles.CollectionChanged += UpdateFreeTiles;
            Subscribe(spaceListener);

            _GestureTemplates.Add(GestureTemplateViewModel.Empty);
            _GestureTemplates.Add(new LeapGestureTemplateViewModel(Gesture.GestureType.TYPECIRCLE)
            {
                Name = "Circle"
            });
            _GestureTemplates.Add(new LeapGestureTemplateViewModel(Gesture.GestureType.TYPEKEYTAP)
            {
                Name = "KeyTap"
            });
            _GestureTemplates.Add(new LeapGestureTemplateViewModel(Gesture.GestureType.TYPESCREENTAP)
            {
                Name = "ScreenTap"
            });

            _GestureTemplates.Add(new LeapGestureTemplateViewModel(Gesture.GestureType.TYPESWIPE)
            {
                Name = "Swipe",
                MinSpeed = 1500
            });
            _PresenterTemplates.Add(new PresenterTemplateViewModel("Not used", "", () => PresenterViewModel.Unused));
            _PresenterTemplates.Add(new PresenterTemplateViewModel("Switch windows", () => new MovePresenterViewModel()
                {
                    OnEnter = Interpreter.Simulate("DOWN ALT"),
                    OnMoveUp = Interpreter.Simulate("PRESS TAB"),
                    OnMoveDown = Interpreter.Simulate(
                                            "DOWN SHIFT",
                                            "PRESS TAB",
                                            "UP SHIFT"),
                    OnRelease = Interpreter.Simulate("UP ALT")
                }
            ));
            _PresenterTemplates.Add(new PresenterTemplateViewModel("Switch windows 2", () => new CyclePresenterViewModel()
            {
                OnEnter = Interpreter.Simulate("DOWN ALT"),
                OnClockWise = Interpreter.Simulate("PRESS TAB"),
                OnCounterClockWise = Interpreter.Simulate(
                                        "DOWN SHIFT",
                                        "PRESS TAB",
                                        "UP SHIFT"),
                OnRelease = Interpreter.Simulate("UP ALT")
            }
            ));
            _PresenterTemplates.Add(new PresenterTemplateViewModel("Volume", () => VolumePresenterViewModel.Create()));
            _PresenterTemplates.Add(new PresenterTemplateViewModel("Dock window", () => new ZonePresenterViewModel()
                {
                    Up = new ZoneTransitionViewModel()
                    {
                        OnEnter = Interpreter.Simulate("PRESS WIN,UP"),
                        OnLeave = Interpreter.Simulate("PRESS WIN,DOWN"),
                    },
                    Down = new ZoneTransitionViewModel()
                    {
                        OnEnter = Interpreter.Simulate("PRESS WIN,DOWN"),
                        OnLeave = Interpreter.Simulate("")
                    },
                    Right = new ZoneTransitionViewModel()
                    {
                        OnEnter = Interpreter.Simulate("PRESS WIN,RIGHT"),
                        OnLeave = Interpreter.Simulate("PRESS WIN,LEFT"),
                    },
                    Left = new ZoneTransitionViewModel()
                    {
                        OnEnter = Interpreter.Simulate("PRESS WIN,LEFT"),
                        OnLeave = Interpreter.Simulate("PRESS WIN,RIGHT"),
                    },
                    Center = new ZoneTransitionViewModel(),

                }));
            _PresenterTemplates.Add(new PresenterTemplateViewModel("Close window", () => new ClickPresenterViewModel()
            {
                OnClicked = Interpreter.Simulate("PRESS ALT,F4")
            }));

            _Debug = new DebugViewModel(this);
            Observable.Interval(TimeSpan.FromSeconds(5.0))
                .ObserveOn(UI)
                .Subscribe(t =>
                {
                    new GestSpaceRepository().Save(this);
                });

            new GestSpaceRepository().Load(this);
            //CurrentTile = Tiles.First(t => !t.IsUnused);
        }
        protected override IDisposable SubscribeCore(ReactiveSpace spaceListener)
        {
            return
                spaceListener
                .ReactiveListener
                .FingersMoves()
                .Concat()
                .ObserveOn(UI)
                .Subscribe(c =>
                {
                    var v = c.TipVelocity.To2D();
                    //v = new Vector(-c.TipVelocity.x, c.TipVelocity.y, 0);

                    var cos = Math.Cos(Helper.DegreeeToRadian(Rotation));
                    var sin = Math.Sin(Helper.DegreeeToRadian(Rotation));

                    var tan = new Vector((float)sin, (float)cos, 0);

                    var man = tan.Dot(v);

                    Rotation -= man / 100;

                });
        }
Esempio n. 14
0
        void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            Dispatcher.BeginInvoke(new Action(() =>
            {

                listener = new ReactiveListener();
                var spaceListener = new ReactiveSpace(listener);

                controller = new Controller(listener);

                ViewModel = new MainViewModel(spaceListener);

                var ui = SynchronizationContext.Current;

                //listener
                //	.FingersMoves
                //	.SelectMany(f => f.ToList().Select(l =>
                //	new
                //	{
                //		Key = f.Key,
                //		Fingers = l
                //	}))
                //	.Subscribe(f =>
                //	{
                //		Console.WriteLine("finger");
                //		try
                //		{
                //			//var max = f.Fingers.Select(ff => GetAngle(ff)).Where(a => a != null).Select(a => a.Value).Max();
                //			var av = f.Fingers.Select(ff => GetAngle(ff)).Where(a => a != null).Select(a => a.Value).Average();
                //			Console.WriteLine("av : " + ((int)av));
                //		}
                //		catch
                //		{
                //			Console.WriteLine("Ex");
                //		}
                //	});

                var centers =
                    listener
                    .FingersMoves()
                    .SelectMany(f => f)
                    .Buffer(TimeSpan.FromMilliseconds(200), TimeSpan.FromMilliseconds(100))
                    .Where(b => b.Count > 0)
                    .Select(b => KeepPopularFinger(b))
                    .Select(v => new
                    {
                        Finger = v.First().Id,
                        Position = new Leap.Vector(v.Average(m => m.StabilizedTipPosition.x), v.Average(m => m.StabilizedTipPosition.y), 0.0f),
                    });

                var moveCenter = listener
                    .FingersMoves()
                    .SelectMany(f => f)
                    .CombineLatest(centers, ViewModel.SpaceListener.IsLocked(), (p, center, locked) => new
                    {
                        Center = center,
                        Position = p.StabilizedTipPosition.To2D(),
                        Move = p.StabilizedTipPosition.To2D() - center.Position,
                        Locked = locked,
                        Finger = p
                    })
                    .Where(p => p.Center.Finger == p.Finger.Id)
                    .Where(p => !p.Locked);

                moveCenter
                    .ObserveOn(ui)
                    .Subscribe(o =>
                    {
                        ViewModel.SelectionPosition = new Point(o.Move.x, o.Move.y);
                    });

                moveCenter
                .Where(o => o.Move.Magnitude >= 50.0)
                .Sample(TimeSpan.FromMilliseconds(1000))
                .ObserveOn(ui)
                .Subscribe(o =>
                {
                    if(ViewModel.Debug.FingerCount <= 2 && ViewModel.State == MainViewState.Navigating)
                    {
                        var angle = Helper.RadianToDegree(Math.Atan2(o.Move.y, o.Move.x));
                        if(!ViewModel.ShowConfig)
                            ViewModel.SelectTile(angle);
                    }
                });

                Dispatcher.BeginInvoke(new Action(() =>
                {
                    Center();
                }));
            }));
        }