Thanks Rob.

I kept using the CategoryDateTimeXAxis because I cannot guarantee all the points will be equally spaced. It just made my life a little easier if it took care of the spacing for me. I just wish I could tell it to not sort as an optional optimization.

I look forward to anything I can do to optimize the EEG chart as well. I have a C++ guy I work with that is giving me a lot of flack about .NET graphing performance... :)

Hi Mike,

Would it be possible to get your custom implementation of ObservableCollection?  The more I think about it the more I think it actually should be making a difference.  Are you sure that no PropertyChanged notifications are happening when you update the points?

Here is my implementation. Got some of this from the web so I can't really claim it.

I call SuspendNotifications before I start my update then NotifyChanges after. I could have used the AddItem method but in this case when the graph is not visible I do not call NotifyChanges to help with performance.

/*==============================================================================
/ FileName : FastObservableCollection.cs
/
/ Project : Vision.Web
/
/ Compiler(s) : Visual Studio 2012
/
/ Copyright : © 2006-2014 Spectrum Medical Ltd
/
/ Description : This is a custom implementation of an ObservableCollection
* that can be updated on a non UI thread and is supposed to be faster than the
* default implementation of ObservableCollection by allowing a single collection
* changed notification for a series of changes rather than one notification for
* each individual change.
/
/=============================================================================*/
using System.Collections.Specialized;
using System.Collections.ObjectModel;
using System.Collections;
using System;
using System.Windows.Threading;
using System.Collections.Generic;

namespace LiveOR.Classes.Collections
{
/// <summary>
/// This is a custom implementation of an ObservableCollection that can be updated on a non UI thread and is supposed to be faster than the
/// default implementation of ObservableCollection by allowing a single collection changed notification for a series of changes rather than one notification for
/// each individual change
/// </summary>
/// <typeparam name="T"></typeparam>
/// <remarks reqid="0003" type="eng">The LiveOR Classes dll will provide a class to define a custom implementation of an ObservableCollection for handling collections that have many elements modified in groups</remarks>
[Serializable]
public class FastObservableCollection<T> : ObservableCollection<T>
{
/// <summary>
/// This private variable holds the flag to
/// turn on and off the collection changed notification.
/// </summary>
private bool suspendCollectionChangeNotification;

/// <summary>
/// Initializes a new instance of the FastObservableCollection class.
/// </summary>
public FastObservableCollection()
: base()
{
this.suspendCollectionChangeNotification = false;
}

public FastObservableCollection(IEnumerable<T> list)
: base(list)
{
}

/// <summary>
/// This event is overriden CollectionChanged event of the observable collection.
/// </summary>
[field:NonSerialized]
public override event NotifyCollectionChangedEventHandler CollectionChanged;

/// <summary>
/// This method adds the given generic list of items as a range into current collection by casting them as type T.
/// It then notifies once after all items are added.
/// </summary>
/// <param name="items">The source collection.</param>
public void AddItems(IList items)
{
this.SuspendCollectionChangeNotification();
try
{
foreach (var i in items)
{
InsertItem(Count, (T)i);
}
}
catch (Exception ex)
{
throw new InvalidCastException("Please check the type of item.", ex);
}
finally
{
this.NotifyChanges();
}
}

/// <summary>
/// Raises collection change event.
/// </summary>
public void NotifyChanges()
{
this.ResumeCollectionChangeNotification();
var arg = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset);
this.OnCollectionChanged(arg);
}

/// <summary>
/// This method removes the given generic list of items as a range
/// into current collection by casting them as type T.
/// It then notifies once after all items are removed.
/// </summary>
/// <param name="items">The source collection.</param>
public void RemoveItems(IList items)
{
this.SuspendCollectionChangeNotification();
try
{
foreach (var i in items)
{
Remove((T)i);
}
}
catch (Exception ex)
{
throw new InvalidCastException(
"Please check the type of items getting removed.", ex);
}
finally
{
this.NotifyChanges();
}
}

/// <summary>
/// Resumes collection changed notification.
/// </summary>
public void ResumeCollectionChangeNotification()
{
this.suspendCollectionChangeNotification = false;
}

/// <summary>
/// Suspends collection changed notification.
/// </summary>
public void SuspendCollectionChangeNotification()
{
this.suspendCollectionChangeNotification = true;
}

/// <summary>
/// This collection changed event performs thread safe event raising.
/// </summary>
/// <param name="e">The event argument.</param>
protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
{
// Recommended is to avoid reentry
// in collection changed event while collection
// is getting changed on other thread.
using (BlockReentrancy())
{
if (!this.suspendCollectionChangeNotification)
{
NotifyCollectionChangedEventHandler eventHandler = this.CollectionChanged;
if (eventHandler == null)
{
return;
}

// Walk thru invocation list.
Delegate[] delegates = eventHandler.GetInvocationList();

foreach (NotifyCollectionChangedEventHandler handler in delegates)
{
// If the subscriber is a DispatcherObject and different thread.
DispatcherObject dispatcherObject = handler.Target as DispatcherObject;

try
{
if (dispatcherObject != null && !dispatcherObject.CheckAccess())
{
// Invoke handler in the target dispatcher's thread...
// asynchronously for better responsiveness.
dispatcherObject.Dispatcher.BeginInvoke(DispatcherPriority.DataBind, handler, this, e);
}
else
{
// Execute handler as is.
handler(this, e);
}
}
catch (Exception)
{
// I keep getting null exceptions here for some reason. Throwing them on the floor to see if
// the application still functions properly if I do
}

}
}
}
}
}
}

empty

Hello Mike,

Thanks for clarifying.  The information in this thread should prove useful to the community.

Let me know if you have any further questions.

We have a tablet with an Intel N2600 Atom processor so it is very low power. I believe it has GMA 3600 graphics chip.

Hi Mike,

Interesting.  I'm curious as to what kind of graphics processor the tablet has.  I haven't really seen cases where software rendering is actually better than hardware rendering but if the graphics processor is just that bad then I guess it could give you a boost.  I never even thought about considering that.  Nice find!

I believe I understand. Thanks.

On my desktop I do see acceptable performance. I have been working with the resolution and decreasing the number of points I plot but I do not see significant gains in performance vs. the loss of accuracy in the graph. I did find out that if I force software rendering mode I get a nice performance boost on the tablet so this may make the app acceptable.

Thanks for the help.

Mike