public IObservable <Mat> Process(IObservable <Tuple <short, short, short, short, short, short> > source) { var skip = Skip; var sourceBuffer = skip.HasValue ? source.Buffer(Count, skip.Value) : source.Buffer(Count); return(sourceBuffer.Select(buffer => Mat.FromArray(ToArray(buffer)))); }
public static void TimedWindowsWithBuffer() { IObservable <int> wordGroupCounts = from wordGroup in words.Buffer(TimeSpan.FromSeconds(6)) select wordGroup.Count * 10; wordGroupCounts.Subscribe(c => Console.WriteLine("Words per minute: " + c)); keySource.Run(); }
/// <summary> /// Projects each element of an observable sequence into zero or more buffers /// based on element count information. /// </summary> /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam> /// <param name="source">The source sequence to produce buffers over.</param> /// <returns>An observable sequence of buffers.</returns> public IObservable <IList <TSource> > Process <TSource>(IObservable <TSource> source) { var skip = Skip; if (skip.HasValue) { return(source.Buffer(Count, skip.Value)); } else { return(source.Buffer(Count)); } }
public MainWindow() { IObservable <EventPattern <MouseEventArgs> > move = Observable.FromEventPattern <MouseEventArgs>(this, "MouseMove"); IObservable <int> data = from evt in move select(int) evt.EventArgs.GetPosition(this).X; var stats = data.Buffer(50, 1).Scan(0, (cur, acc) => { stdDev = acc.StdDev(); mean = acc.Average(); return(0); }); stats.Subscribe(); Dictionary <string, IObservable <int> > rules = new Dictionary <string, IObservable <int> >(); rules.Add("Rule1", data.Buffer(1, 1).Scan(0, (cur, acc) => (Math.Abs((acc.Last() - mean)) > Math.Abs(((3 * stdDev) - mean))) ? 1 : 0)); rules.Add("Rule2", data.Buffer(9, 1).Scan(0, (cur, acc) => (acc.All(x => x < mean) || acc.All(x => x > mean)) ? 1 : 0)); rules.Add("Rule3", data.Buffer(6, 1).Scan(0, (cur, acc) => (acc.IsDecreasing() || acc.IsIncreasing()) ? 1 : 0)); rules.Add("Rule4", data.Buffer(14, 1).Scan(0, (cur, acc) => (acc.Where((x, i) => i % 2 == 0).All(p => p > mean) || acc.Where((x, i) => i % 2 == 0).All(p => p < mean)) ? 1 : 0)); rules.Add("Rule5", data.Buffer(3, 1).Scan(0, (cur, acc) => (((acc.Where(p => p > mean).Where(p => Math.Abs(p - mean) > (2 * stdDev)).Count() > 1) || (acc.Where(p => p < mean).Where(p => Math.Abs(p - mean) > (2 * stdDev)).Count() > 1))) ? 1 : 0)); rules.Add("Rule6", data.Buffer(5, 1).Scan(0, (cur, acc) => (((acc.Where(p => p > mean).Where(p => Math.Abs(p - mean) > stdDev).Count() > 3) || (acc.Where(p => p < mean).Where(p => Math.Abs(p - mean) > stdDev).Count() > 3))) ? 1 : 0)); rules.Add("Rule7", data.Buffer(15, 1).Scan(0, (cur, acc) => (((acc.Where(p => p > mean).Where(p => Math.Abs(p - mean) < stdDev).Count() > 14) || (acc.Where(p => p < mean).Where(p => Math.Abs(p - mean) < stdDev).Count() > 14))) ? 1 : 0)); rules.Add("Rule8", data.Buffer(8, 1).Scan(0, (cur, acc) => ((acc.Where(p => p >= mean).Count() < 8 && acc.Where(p => p <= mean).Count() < 8) && (acc.Count(p => (Math.Abs(p - mean) < stdDev)) > 7)) ? 1 : 0)); _results = new ObservableCollection <ItemEntry>(); for (int i = 1; i <= 8; i++) { _results.Add(new ItemEntry("Rule" + i, false)); } for (int p = 0; p <= 7; p++) { ItemEntry e = _results[p]; rules["Rule" + (p + 1)].Subscribe(x => e.IsSelected = (x == 1) ? true : false); } this.DataContext = this; }
/// <summary> /// ZLEMA = EMA of (close + (close-close[lag])) /// </summary> /// <param name="source"></param> /// <param name="period"></param> /// <returns></returns> public static IObservable <double> ZLEMA(this IObservable <double> source, uint period) { int lagP = (int)(period - 1) / 2; lagP = lagP + 1; return(source.Buffer(lagP, 1).Where(x => x.Count == lagP).Select(x => 2 * x[lagP - 1] - x[0]).EMA(period)); }
public BME280Sensor(I2CBusPI bus, IObservable <Unit> pollingTrigger) { var sensor = new BoschDevices.BME280Sensor(bus, 1014); var delay = TimeSpan.FromMilliseconds(500); CurrentTemperature = pollingTrigger.Buffer(delay).Select(_ => (double)sensor.ReadTemperature().Result); }
public IObservable <IChangeSet <TObject> > Run() { return(Observable.Create <IChangeSet <TObject> >( observer => { var locker = new object(); var allItems = new List <ObjWithFilterValue>(); var shared = _source.Synchronize(locker).Transform(v => new ObjWithFilterValue(v, true)) // we default to true (include all items) .Clone(allItems) // clone all items so we can look up the index when a change has been made .Publish(); // monitor each item observable and create change, carry the value of the observable property IObservable <ObjWithFilterValue> itemHasChanged = shared.MergeMany(v => _filter(v.Obj).Select(prop => new ObjWithFilterValue(v.Obj, prop))); // create a change set, either buffered or one item at the time IObservable <IEnumerable <ObjWithFilterValue> > itemsChanged = _buffer is null ? itemHasChanged.Select(t => new[] { t }) : itemHasChanged.Buffer(_buffer.Value, _scheduler ?? Scheduler.Default).Where(list => list.Count > 0); IObservable <IChangeSet <ObjWithFilterValue> > requiresRefresh = itemsChanged.Synchronize(locker).Select( items => { // catch all the indices of items which have been refreshed return IndexOfMany(allItems, items, v => v.Obj, (t, idx) => new Change <ObjWithFilterValue>(ListChangeReason.Refresh, t, idx)); }).Select(changes => new ChangeSet <ObjWithFilterValue>(changes)); // publish refreshes and underlying changes var publisher = shared.Merge(requiresRefresh).Filter(v => v.Filter).Transform(v => v.Obj).SuppressRefresh() // suppress refreshes from filter, avoids excessive refresh messages for no-op filter updates .SubscribeSafe(observer); return new CompositeDisposable(publisher, shared.Connect()); })); }
/// <summary> /// Buffers a sequence of characters based on a pair of delimiters. /// </summary> /// <param name="source">The source sequence.</param> /// <param name="initiator">The initiator character. Optional; default is ':'."</param> /// <param name="terminator">The terminator character. Optional; default is '#'."</param> /// <returns><see cref="IObservable{T}" /> - an observable sequence of buffers.</returns> public static IObservable <IList <char> > BufferByDelimiters(IObservable <char> source, char initiator = ':', char terminator = '#') { Contract.Requires(source != null); Contract.Ensures(Contract.Result <IObservable <IList <char> > >() != null); return(source.Buffer(source.Where(c => c == initiator), x => source.Where(c => c == terminator))); }
public static IObservable <IList <T> > Buffer <T>( this IObservable <T> source, TimeSpan?timeSpan, int?count, IScheduler scheduler) { if (!timeSpan.HasValue) { return(count.HasValue ? source.Buffer(count.Value) : source.ToList()); } // Need to consider timespan if (!count.HasValue) // No count either { return(scheduler is null?source.Buffer(timeSpan.Value) : source.Buffer(timeSpan.Value, scheduler)); } return(scheduler is null ? source.Buffer(timeSpan.Value, count.Value) : Observable.Buffer(source, timeSpan.Value, count.Value, scheduler)); }
public IObservable<FileSystemChange> Configure(IObservable<FileSystemChange> observable) { // http://stackoverflow.com/questions/9985125/in-rx-how-to-group-latest-items-after-a-period-of-time return observable.Buffer(() => observable.Throttle(TimeSpan.FromSeconds(2)).Timeout(TimeSpan.FromMinutes(1))) .PrioritizeFileSystemChanges() .SelectMany(x => x); }
public Window1() { //Setup twitter //IFluentTwitter twitclient = FluentTwitter.CreateRequest().AuthenticateAs("uid", "pwd"); //ITwitterStatuses twitStatuses = twitclient.Statuses(); //generate temperature alerts ObservableUsbTemper temperature = new ObservableUsbTemper(); IObservable <double> ts = temperature.TemperatureStreamFarenheight; IObservable <IList <double> > tsSlidingWindow = ts.Buffer(TimeSpan.FromSeconds(5)); IObservable <double> avgTempOverTime = tsSlidingWindow.Select(buff => buff.Average()); IObservable <double> tempAlerts = avgTempOverTime.Where(avgtemp => avgtemp < 80); // Send to twitter IObservable <string> twitterResponses = tempAlerts.Sample(TimeSpan.FromMinutes(1)) .Select(cold => string.Format("It's cold here. Avg temp is {0:0.00}", cold)); // now wire-up the UI InitializeComponent(); this.DataContext = this; OCFarenheightReadings = new ObservableCollection <double>(); OCSlidingWindow = new ObservableCollection <IList <double> >(); OCavgTempOverTime = new ObservableCollection <double>(); OCtempAlerts = new ObservableCollection <double>(); OCtwitterResponses = new ObservableCollection <string>(); OCFarenheightReadings.Insert(ts); OCSlidingWindow.Insert(tsSlidingWindow); OCavgTempOverTime.Insert(avgTempOverTime); OCtempAlerts.Insert(tempAlerts); OCtwitterResponses.Insert(twitterResponses); }
public AutoTrackingTable (DatabaseFront database, string name, double trackIntervalTime, IObservable <TRecord> itemAddedObservable, int version) { this.Table = new TypedTable <TRecord, TKey>(database, name) { IsIdAuto = false, Version = version, }; this.Tracker = new Tracker <TRecord, TKey>(this.Table).AddTo(this.Disposables); itemAddedObservable .Buffer(itemAddedObservable.Throttle(TimeSpan.FromMilliseconds(trackIntervalTime))) .Subscribe(items => { Task.Run(async() => { await this.Table.Parent.RequestThreadSafeTransactionAsync (context => this.Table.AddRangeAsync(items, context.Connection, context.Transaction)) .ConfigureAwait(false); items.ForEach(x => this.Tracker.Track(x)); }); }) .AddTo(this.Disposables); }
public static IObservable <SentimentDelta> ProbabilityDeltas(this IObservable <SentimentProbabilities> source, int count, int skip, Match match) { return(Observable.Create <SentimentDelta>(observer => { return source.Buffer(count, skip).Subscribe(buffer => { var first = buffer.FirstOrDefault(); var last = buffer.LastOrDefault(); var lastInSequence = buffer.Count == 1; observer.OnNext(new SentimentDelta { TeamA = match.TeamA, TeamB = match.TeamB, HomeWinProbabilityDelta = (first == null || last == null) ? 0m : last.HomeWinProbability - first.HomeWinProbability, DrawProbabilityDelta = (first == null || last == null) ? 0m : last.DrawProbability - first.DrawProbability, AwayWinProbabilityDelta = (first == null || last == null) ? 0m : last.AwayWinProbability - first.AwayWinProbability, HomeWinProbabilityCurrent = last == null ? 0m : last.HomeWinProbability, DrawProbabilityCurrent = last == null ? 0m : last.DrawProbability, AwayWinProbabilityCurrent = last == null ? 0m : last.AwayWinProbability, ClosingPrediction = lastInSequence }); }, observer.OnCompleted); })); }
public HazardSpawner( UniRx.IObservable <float> time, float spawnInterval, RandomFloat randomService, float minHazardHeight, float maxHazardHeight, float initialPosition, float hazardSpeed ) { this.randomService = randomService; this.minHazardHeight = minHazardHeight; this.maxHazardHeight = maxHazardHeight; this.initialPosition = initialPosition; this.hazardSpeed = hazardSpeed; this.time = time; spawning = true; // Transform the time to emit events every 'spawnInterval' seconds Hazards = time .Buffer(Span(spawnInterval)) // Put an event at the beginning of the time-line .StartWith(FirstSpawnEvent()) // Only spawn if 'spawning' is on .Where(_ => spawning) // transform the spawn events into hazards .Select(l => HazardFactory()); }
public static IObservable <TSource> BufferUntilCompatibilityChecked <TSource>(this XafApplication application, IObservable <TSource> source) { var compatibilityCheckefd = application.WhenCompatibilityChecked().Select(xafApplication => xafApplication).FirstAsync(); return(source.Buffer(compatibilityCheckefd).FirstAsync().SelectMany(list => list) .Concat(Observable.Defer(() => source)).Select(source1 => source1)); }
private void Init(FileSystemWatcher watcher, IEnumerable <FileInfo> files, int bufferTime, int intervalTime, Predicate <FileInfo> inactive) { this.states = new FileStateManager(files, inactive); watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Size; watcher.Created += this.OnObjectChanged; watcher.Renamed += this.OnObjectRenamed; watcher.Deleted += this.OnObjectChanged; IObservable <FileSystemEventArgs> listener = Observable.FromEvent <FileSystemEventHandler, FileSystemEventArgs>( handler => (sender, e) => { handler(e); }, h => watcher.Changed += h, h => watcher.Changed -= h); var triggerInterval = TimeSpan.FromMilliseconds(intervalTime); IObservable <IList <FileSystemEventArgs> > listener2 = Observable.Interval(triggerInterval) // .Debug(() => "Interval listener triggered {0}.".FormatWith(DateTime.Now.ToLongTimeString())) .SelectMany(l => this.states.Files) .Where(this.SizeChanged) .Select(file => new FileSystemEventArgs(WatcherChangeTypes.Changed, file.DirectoryName, file.Name)) .Buffer(triggerInterval); this.subscription = listener .Buffer(TimeSpan.FromMilliseconds(bufferTime)) .Merge(listener2) .Subscribe(OnObjectChanged); watcher.EnableRaisingEvents = true; this.watcher = watcher; Debug.WriteLine("Initialized \"{0}\" with {1} active files.".FormatWith(watcher.Path, this.states.Files.Count)); }
public static IObservable <IList <TSource> > Buffer <TSource> ( this IObservable <TSource> source, TimeSpan timeSpan, IScheduler scheduler) { return(source.Buffer(timeSpan, int.MaxValue, scheduler)); }
public static IObservable <IList <TSource> > BufferNotEmpty <TSource>( this IObservable <TSource> source, TimeSpan timeSpan, int count) { return(source.Buffer(timeSpan, count).Where(_ => _.Any())); }
public SmoothingWithBuffer() { InitializeComponent(); IObservable <EventPattern <MouseEventArgs> > downs = Observable.FromEventPattern <MouseEventArgs>( background, nameof(background.MouseDown)); IObservable <EventPattern <MouseEventArgs> > ups = Observable.FromEventPattern <MouseEventArgs>( background, nameof(background.MouseUp)); IObservable <EventPattern <MouseEventArgs> > allMoves = Observable.FromEventPattern <MouseEventArgs>( background, nameof(background.MouseMove)); IObservable <EventPattern <MouseEventArgs> > dragMoves = from down in downs join move in allMoves on ups equals allMoves select move; IObservable <EventPattern <MouseEventArgs> > allDragPositionEvents = Observable.Merge(downs, ups, dragMoves); IObservable <Point> dragPositions = from move in allDragPositionEvents select move.EventArgs.GetPosition(background); IObservable <Point> smoothed = from points in dragPositions.Buffer(5, 2) let x = points.Average(p => p.X) let y = points.Average(p => p.Y) select new Point(x, y); smoothed.Subscribe(point => { line.Points.Add(point); }); }
public static T WaitFirstValue <T>(this IObservable <T> observable, TimeSpan timeout) { return(observable.Buffer(timeout, 1) .ToEnumerable() .First() .First()); }
private static void ObserveScenarioOuput(IObservable<int> count) { count .Sum() .Subscribe(total => ScenarioSimulatorEventSource.Log.FinalEventCountForAllDevices(total)); count .Buffer(TimeSpan.FromMinutes(5)) .Scan(0, (total, next) => total + next.Sum()) .Subscribe(total => ScenarioSimulatorEventSource.Log.CurrentEventCountForAllDevices(total)); count .Buffer(TimeSpan.FromMinutes(0.1)) .TimeInterval() .Select(x => x.Value.Sum() / x.Interval.TotalSeconds) .Subscribe(rate => ScenarioSimulatorEventSource.Log.CurrentEventsPerSecond(rate)); }
public override void ObserveResponse(IObservable <char> source) { source.Buffer(completeAfter) .Select(p => new string(p.ToArray())) //.ObserveOn(NewThreadScheduler.Default) .Take(1) .Subscribe(OnNext, OnError, OnCompleted); }
/// <summary> /// Bulks the trigger. /// </summary> /// <param name="streamRate">The stream rate.</param> /// <param name="scheduler">The scheduler.</param> /// <returns></returns> public IObservable<Unit> BulkTrigger( IObservable<Unit> streamRate, IScheduler scheduler) { var result = streamRate.Buffer(3) .Select(_ => Unit.Default); return result; }
private static void ObserveScenarioOuput(IObservable <int> count) { count .Sum() .Subscribe(total => ScenarioSimulatorEventSource.Log.FinalEventCountForAllDevices(total)); count .Buffer(TimeSpan.FromMinutes(5)) .Scan(0, (total, next) => total + next.Sum()) .Subscribe(total => ScenarioSimulatorEventSource.Log.CurrentEventCountForAllDevices(total)); count .Buffer(TimeSpan.FromMinutes(0.1)) .TimeInterval() .Select(x => x.Value.Sum() / x.Interval.TotalSeconds) .Subscribe(rate => ScenarioSimulatorEventSource.Log.CurrentEventsPerSecond(rate)); }
public static void ShouldStartWithIn <T>(this IObservable <T> observable, TimeSpan timeout, params T[] values) { observable.Buffer(timeout, values.Length) .ToEnumerable() .First() .Should() .Equal(values); }
// .-|.-|.-| public static IObservable <EyeMovement> MergeAdjacentFixations(this IObservable <EyeMovement> movements, TimeSpan maxTimeBetweenFixations, double maxAngleBetweenFixations) { return(movements.Buffer(m => m.MovementType == EyeMovementType.Fixation) .Scan((aggregate, buffer) => { if (aggregate.Any()) { var lastFixation = aggregate.FirstOrDefault(m => m.MovementType == EyeMovementType.Fixation); var nextFixation = buffer.FirstOrDefault(m => m.MovementType == EyeMovementType.Fixation); var nextMovements = buffer.Except(new[] { nextFixation }).ToArray(); if (lastFixation != null && nextFixation != null) { var timeBetweenFixations = (nextFixation.Timestamp - lastFixation.EndTimestamp); if (timeBetweenFixations <= maxTimeBetweenFixations) { var lastSample = lastFixation.Samples.Last().Eye; var nextSample = nextFixation.Samples.First().Eye; var averageSample = EyeSampleUtils.Average(lastSample, nextSample); double angle = averageSample.GetVisualAngle(lastFixation.AverageSample, nextFixation.AverageSample); if (angle <= maxAngleBetweenFixations) { var mergedSamples = aggregate.SelectMany(m => m.Samples).Concat(nextFixation.Samples); var newAverageSample = EyeSampleUtils.Average(lastFixation.Samples.Concat(nextFixation.Samples).Select(s => s.Eye)); // merge var mergedFixation = new List <EyeMovement>() { new EyeMovement ( EyeMovementType.Fixation, mergedSamples, newAverageSample, lastFixation.Timestamp, nextFixation.EndTimestamp ) }; if (nextMovements != null && nextMovements.Any()) { mergedFixation.AddRange(nextMovements); } return mergedFixation; } } } } return buffer; }) .Where(b => b.Any()) .Buffer((first, current) => first.First().Timestamp != current.First().Timestamp) .Where(b => b.Any()) .Select(b => b.Last()) .SelectMany(b => b)); }
public static IObservable <IOhlcvv> Ohlcvv(this IObservable <IExecution> source, TimeSpan frameSpan, bool insertMissingFrames = false) { if (!insertMissingFrames) { return(source .Buffer(e => e.Time, frameSpan) .Select(e => new Ohlcvv(frameSpan, e))); } return(Observable.Create <IOhlcvv>(observer => { var prev = default(Ohlcvv); var disposable = source .Buffer(e => e.Time, frameSpan) .Select(e => new Ohlcvv(frameSpan, e)) .Subscribe(current => { if (prev == default) { observer.OnNext(current); } else if (current.Start == prev.Start + frameSpan) { observer.OnNext(current); } else { var ohlc = prev; while (true) { ohlc = ohlc.CreateMissingFrame(); observer.OnNext(ohlc); if (ohlc.Start == current.Start - frameSpan) { break; } } observer.OnNext(current); } prev = current; }); return Disposable.Create(disposable.Dispose); })); }
/// <summary> /// Bulks the trigger. /// </summary> /// <param name="streamRate">The stream rate.</param> /// <param name="scheduler">The scheduler.</param> /// <returns></returns> public IObservable <Unit> BulkTrigger( IObservable <Unit> streamRate, IScheduler scheduler) { var result = streamRate.Buffer(3) .Select(_ => Unit.Default); return(result); }
private IObservable <IList <SwatcherCreatedEventArgs> > CreateCreatedEventWindowStream( IObservable <SwatcherCreatedEventArgs> createdEventStream) { return(createdEventStream .Buffer(OneSecond, QuarterSecond) .CombineWithPreviousBuffer() .Publish() .RefCount()); }
public static IObservable <double> ToDistance(this IObservable <MouseEventArgs> e) { return(e.Buffer(2, 1) .Select(b => { var d = Distance(b[0].Location, b[1].Location); return d; })); }
protected override IObservable <RHD2164DataFrame> Process(IObservable <ONIManagedFrame <ushort> > source, ulong frameOffset) { var ephysDataFormat = EphysDataFormat; var auxDataFormat = AuxDataFormat; return(source .Buffer(BlockSize) .Select(block => { return new RHD2164DataFrame(block, frameOffset, ephysDataFormat, auxDataFormat); })); }
internal static IObservable <double> AroonUp_V1(this IObservable <double> source, int period) { return(source.Buffer(period, 1).Where(x => x.Count == period) .Select(lt => { var y = lt.Max(); var idx = period - (lt.IndexOf(y) + 1); return (period - idx) * (100.0 / period); })); }
public static IObservable <TResult> MovingAverageWithBuffer <TItem, TAccumulate, TResult> ( this IObservable <TItem> source, TAccumulate seed, int windowSize, Func <TAccumulate, TItem, TAccumulate> addAccumulate, Func <TAccumulate, TItem, TAccumulate> subtractAccumulate, Func <TAccumulate, int, TItem, TResult> average ) { return(Observable.Create <TResult>(observer => { return source.Buffer(windowSize * 2 + 1, 1) .Scan ( seed: new MovingAverageBuffer <TAccumulate, TItem> ( accumulate: seed, add: addAccumulate, subtract: subtractAccumulate ), accumulator: (aggregate, buffer) => { if (aggregate.IsInitialized == false) { aggregate.Initialize(buffer); } else if (buffer.Count < aggregate.Count) { aggregate.First = buffer.First(); } else { aggregate.Last = buffer.Last(); aggregate.First = buffer.First(); } int count = buffer.Count; //if (count != aggregate.Count) //{ // Console.WriteLine("xxxx"); //} if (count % 2 == 1) { var current = buffer[count / 2]; observer.OnNext(average(aggregate.Accumulate, count, current)); } return aggregate; } ).Subscribe(_ => { }, () => observer.OnCompleted()); })); }
public IObservable<bool> DetectCorrectKeypass(IObservable<string> keypresses, string password, TimeSpan delay, IScheduler scheduler) { return keypresses .Buffer(delay, password.Length, scheduler) .Select(listStr => string.Join(string.Empty, listStr.ToArray())) .Do(guess => EnteredPassKey = guess) .Where(guess => guess != string.Empty) .Select(guess => guess == password) .DistinctUntilChanged(); }
public static IObservable<float> Filter(IObservable<float> src, int bufferSize, int dropSize, int takeSize) { return src.Buffer(bufferSize).Select((buffered, index) => ApplyFilter(buffered, index, dropSize, takeSize)); }
public IObservable<IEnumerable<DataPoint>> Apply(IObservable<DataPoint> dataPoints) { return dataPoints.Buffer(BufferSize); }