C# WPF: einfache Pixel (für Messkurven) malen?

[Bronco (Gast)]

Hallo zusammen,

ich möchte in einem C# WPF-Programm Messkurven malen, indem ich einer 
Zeichenfläche zyklisch Messpunkte als Pixel hinzufüge.

Im Augenblick mach ich das über ein Canvas mit einer Polyline, wobei ich 
der Polyline für jeden Messpunkt einen Point hinzufüge. Funktioniert 
gut, allerdings wird das Programm mit der Zeit immer langsamer, was ich 
darauf zurückführe, dass die Verwaltung der vielen Point-Objekte immer 
aufwendiger wird. Denn wenn ich die Points der Polyline lösche, ist die 
Geschwindigkeit sofort wieder da.
Wenn ich hingegen einfach "unverwaltete" Pixel malen könnte, hätte ich 
das Problem nicht.

Beim Googlen hab ich leider keine Alternative gefunden. Was könnte man 
da machen?

[Babbage (Gast)]

Wie wärs damit:
Generating Graphs with WPF
https://msdn.microsoft.com/en-us/magazine/ff714591.aspx

Ist schon ein paar Jahre alt aber immer noch top.

[Odrr! (Gast)]

Evtl. auch mal das hier anschauen:
https://writeablebitmapex.codeplex.com/

[mitleser (Gast)]

Hi,

ich nehme immer

"zedgraph"

Gruß

[Günter R. (muntablues)]

Zeig mal wie du die Punkte hinzu fügst. Ich denke da kann man noch sehr 
viel optimieren.

Vor allem würde ich immer nur die letzten, sagen wir mal 100, Punkte an 
die View übergeben, dann hast du ganz bestimmt kein Problem. Einfach im 
Viewmodel die Polyline Punkte beschneiden und dann haut das sicher hin.

So denn,

[Bronco (Gast)]

Günter R. schrieb:
> Zeig mal wie du die Punkte hinzu fügst. Ich denke da kann man noch
> sehr viel optimieren.

amplitudeLine     = new Polyline;
...
amplitudeLine.Points.Add(new Point(x, y));

Was willst Du da groß optimieren?


> Vor allem würde ich immer nur die letzten, sagen wir mal 100, Punkte an
> die View übergeben,
Aber dann werden alle älteren gelöscht/verdrängt, oder? Ich brauche die 
aber noch.

[Draco (Gast)]

Speichere den Rest doch einfach in nem normalen Array ab und bei Bedarf 
rufst du sie daraus auf?!?

[Günter R. (muntablues)]

Bronco schrieb:
> Aber dann werden alle älteren gelöscht/verdrängt, oder? Ich brauche die
> aber noch.

Du kannst ja im Viewmodel die Daten für die Polyline filtern und nur die 
letzten anzeigen. Je nach Größe des Controls auf dem die Polyline 
gezeichnet wird, würde ich das anpassen.

Alles zusammen würde ich das ca. so machen:

    class ViewModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        private const int NumberOfDrawingPoints = 100;
        private readonly List<double> amplitudes;

        private PointCollection polylinePoints;


        public ViewModel()
        {
            amplitudes = new List<double>(); 
            PolylinePoints = new PointCollection();
        }

        public PointCollection PolylinePoints
        {
            get { return polylinePoints; }
            set
            {
                polylinePoints = value;
                NotifyOfPropertyChange();
            }
        }

        public void AddMeasurement(double value)
        {
            amplitudes.Add(value);
            CalculatePoints();
        }

        private void CalculatePoints()
        {
            // take only last 100 points of amplitudes
            var drawingPoints = amplitudes.Skip(Math.Max(0, amplitudes.Count() - NumberOfDrawingPoints)).ToArray();
            var points = new PointCollection();
            for (int i = 0; i < drawingPoints.Count(); i++)
            {
                // TODO: X scale 
                points.Add(new Point(i, drawingPoints[i]));
            }
            PolylinePoints = points;
        }

        protected virtual void NotifyOfPropertyChange([CallerMemberName] string propertyName = null)
        {
            var handler = PropertyChanged;
            if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }

[BSJ (Gast)]

Denkbar wäre auch eine eigene Queue die INotifyPropertyChanged 
implementiert.
Damit hast du zwar nur die letzten x Samples zu Anzeige verfügbar, musst 
dich jedoch nicht um irgendwelche ArrayGrenzen usw kümmern.
Damit wird das Zeichnen zu reinem und lesbaren XAML Code.

[Bronco (Gast)]

Danke für die Tips, aber die Beschränkung der Anzahl von Punkten geht an 
meinem Ziel vorbei. Ich will Meßkurven über einen längeren Zeitraum 
aufzeichnen können.
Natürlich gäbe es da Möglichkeiten, z.B. nur größere Änderungen 
anzuzeigen und die kleineren unter den Tisch fallen zulassen, aber im 
Grunde möchte ich einfach "malen können".

[Günter R. (muntablues)]

Das kann man auch, wenn man es richtig macht...

Wieviel Messwerte hast pro Stunde und wie groß ist die "Zeichenfläche"? 
Ab wieviel Punkten fängt es an merklich zu bremsen?