Articles on marsipu's Blog

Blog Week 11 (16.08.-20.08.)

beetlejuice920@gmail.com (marsipu) — Sun, 22 Aug 2021 20:15:35 +0000

What did I do this week?

During this week I worked on left features, adapting the pyqtgraph-backend to tests and fixing remaining bugs. I also wrapped up GSoC by writing a final report. There you can also find instructions on how to test the new backend. I opened a WIP-PR for my mentors to review my work on the new backend. There are still things to do left, which I listed in this issue. And finally I completed the final GSoC-Evaluation.

Where did I get stuck?

At the beginning of the week I really got stuck with implementing fake clicks for pyqtgraph, which are then used by several tests. I had to try a lot and consulted my mentors often until I luckily finally could get it to work never the less.

Thank you!

Since this was my last official week of Google Summer of Code, I will no longer blog here. But you can still reach me via dev@earthman-music.de if you got questions or ideas regarding the new pyqtgraph-backend or other related topics. It was a great experience for me to work on such a project full time before I start my clinical elective next year. I hope that the new backend facilitates the step of data-preprocessing of MEG/EEG-Data for the MNE-Python-Users. Thank you to the pyqtgraph-developers who with their package facilitated accomplishing my project-goals a lot. And a lot of thanks to my mentors, who were always in reach and provided help and feedback wherever they could.

So long, see you on GitHub:)

Weekly Check-In Week 10 (09.08.-13.08.)

beetlejuice920@gmail.com (marsipu) — Sun, 15 Aug 2021 14:39:49 +0000

What did I do this week?

After having finished refactoring most of the refactoring of the matplotlib-backend, this PR could now be merged into MNE-Python. When I started on prototyping with pyqtgraph, I build my own framework for loading and processing data and forwarding parameters into the prototype for visualization. This week I worked a lot on adapting the pyqtgraph-prototype to the framework mne-python provides. Furthermore I noticed, that performance is heavily depending on wether the data is already preloaded in memory. But this can be limiting for large datasets or devices with little amount of RAM. We therefore thought about having a separate thread for loading the data only up to a given range around the visible range.

What is coming up next?

To integrate the pyqtgraph-backend into mne-python, a lot of tests still need to be adapated. And there are some features from the current matplotlib backend missing. When the former is done, we will start then a PR for the first integration of the pyqtgraph-backend as an experimental features.

Blog Week 9 (02.08.-06.08.)

beetlejuice920@gmail.com (marsipu) — Fri, 06 Aug 2021 13:23:02 +0000

What has been done?

The biggest part of the week was taken again by the refactoring of the existing matplotlib-backend inside MNE-Python. I discussed the changes with my mentors on the Pull-Request and implemented their feedback. Now we are at a point, where we probably can merge this first PR soon to pave the way for the next PR with the integration of the pyqtgraph-backend.

What is coming next?

Now that the refactoring is mostly done I will focus again on the pyqtgraph-backend and its adaption to the parent-class BrowserBase which will be inherited by both backends. Furthermore there need to be new methods to test the pyqtgraph-backend (mouse/keyboard-interaction), which may be solved with pytest-qt.

Weekly Check-In Week 8 (26.07.-30.07.)

beetlejuice920@gmail.com (marsipu) — Fri, 30 Jul 2021 12:20:09 +0000

What did I do this week?

As last week this week was about refactoring the existing matplotlib-backend into a new BrowserBase-Class. This time the main-focus was the refactoring of the tests. This included reorganizing the data-import, adding abstract-methods for interaction and adjusting the backend-selection to a get/set/use scheme.
To fix the problem that lines looked different when OpenGL was activated, I opened a PR for pyqtgraph.

What is coming up next?

After finishing the current PR about refactoring the matplotlib-backend, I will soon open a second PR for the integration of the new pyqtgraph-backend into MNE-Python. For this I have to first apply the changes I made to BrowserBase on to the PyQtGraph-Browser-Class and adapt the tests where necessary to make them pass with both possible backends.

Did you get stuck anywhere?

I had some questions about how to refactor the tests (and what pytest-fixtures would have to do with that) which could be resolved by my mentors.

Blog Week 7 (19.07.-23.07.)

beetlejuice920@gmail.com (marsipu) — Mon, 26 Jul 2021 09:50:10 +0000

A week of Refactoring

During the last week I focused on refactoring the backend-independent methods of the matplotlib-backend already implemented in MNE-Python into a new parent-class called BrowserBase. This shall facilitate the side-by-side integration of the new pyqtgraph-backend and avoid duplication of those methods which can be used similiary for both backends (as preparing/preprocessing the data, processing the parameters, etc.).

Next week

I am currently working on refactoring the tests in the same manner so that the pyqtgraph-tests can be integrated into the already existing tests. Afterwards I will start with adjusting the pyqtgraph-prototyp, which until now relies on provisional data-preparation, to BrowserBase.

Weekly Check-In Week 6 (12.06.-16.07.)

beetlejuice920@gmail.com (marsipu) — Fri, 16 Jul 2021 10:57:59 +0000

What did I do this week?

During this week I mainly fixed bugs (scrolling, annotations, benchmarks). Some new features included a downsampling-test and channel-colors. As my mentors suggested to refactor the existing matplotlib-backend into a subclass inheriting from an abstract base-class for plotting I read more into the structure of the matplotlib-backend and equivalent backends of MNE-Python.

What is coming up next?

Displaying Epochs is the biggest feature which is still left, so this will be next. The way how epochs-data is handled before display is already implemented in the matplotlib-backend so I will probably benefit from implementing the epochs-display in pyqtgraph while refactoring the epoch-handling methods from the matplotlib-backend.

Did you get stuck anywhere?

At first I struggled a bit on defining what of the existing matplotlib-backend should be refactored and moved into an abstract class, but this could be overcome by consulting my mentors. The refactoring probably will be a side-by-side task now where I refactor the data-management-methods when I need them in the pyqtgraph-backend.

Blog Week 5 (05.07.-09.07.)

beetlejuice920@gmail.com (marsipu) — Sun, 11 Jul 2021 20:32:52 +0000

What did I work on this week?

I worked on the implementation and improvement of features as the mouse-interaction and the annotation-management. There also were still some bugs which appeared during vertical scrolling (lines getting added/removed when they shouldn't) and which were a bit hard to track. To simplify the bug-tracking, I simplified the dynamic loading of lines. With the annotation-manager, I finished a feature which is partly inspired by SigViewer.

Benchmarks

As the performance can still be improved, I ran some benchmarks for the horizontal scrolling to compare different methods of downsampling. With the current version I found:

applying downsampling in chunks decreases performance
the "peak"-downsampling-method from pyqtgraph decreases performance compared to no downsampling

I am still working on ways to improve performance. One way is to activate OpenGL, which improves perfomance a lot. On Windows this may come with future problems, because it only works with an older pyqtgraph-version at the moment.

What comes next?

There are still features left to be implemented before I can open the first PR for an integration into the main-branch of MNE-Python which I will work on. Besides that my mentors advised me to refactor the existing matplotlib-classes to make a side-by-side implementation of both backends more feasible.

Weekly Check-In Week 4 (28.06.-02.07.)

beetlejuice920@gmail.com (marsipu) — Sun, 04 Jul 2021 19:03:47 +0000

What did I do this week?

During this week I mainly worked on the annotations-feature to mark regions for example for exclusion. I also adapted the methods from pyqtgraph for downsampling.

What is coming up next?

After a meeting with my mentors we still confirmed, that pyqtgraph would be the way to go for now and I updated the ToDo-List with all the features which still need to be implemented. As the basic functionality is mostly already working sufficiently we are aiming on integrating the first version of the pyqtgraph-RawBrowser into the MNE-Python development-branch soon.

Did you get stuck anywhere?

Not yet.

Blog Week 3 (28.06.-02.07.)

beetlejuice920@gmail.com (marsipu) — Mon, 28 Jun 2021 16:33:16 +0000

What did I do this week?

I continued with implementing more features into the pyqtgraph-prototype (scrollbars, bad-channel-selection, keyboard-shortcuts) and I fixed several bugs. To investigate the differences in performance between the pyqtgraph-prototype and a barebone PyQt-Prototype I tried to implement the features from the pyqtgraph-prototype there too (see "Did I get stuck anywhere?"). And I recently contacted the community of pyqtgraph for some feedback on the prototype (and to thank them for their great work).

What is coming up next?

There are still features left, especially in terms of markers and the visualization of Epochs. In accordance with my mentors I will continue with implementing those features into the pyqtgraph-backend as this seems to be a viable option as the final backend.

Did I get stuck anywhere?

Working on the barebone PyQt-Prototype I encountered several challenges which haven't been present while I was working with pyqtgraph. For example I couldn't fit the lines to the view and when I tried shifting the visible lines, it resolved in weird artefacts. It was then more than ever that I realized how many problems are solved by pyqtgraph beforehand and as it took to much time to struggle with those problems I now switched back to working on the pyqtgraph-backend. The original performance problem (activating OpenGL for pyqtgraph) turned out to have a very simple solution so now the performance of the pyqtgraph-backend can be better regardless.

Weekly Check-In Week 2 (14.06.-18.06.)

beetlejuice920@gmail.com (marsipu) — Tue, 22 Jun 2021 07:22:33 +0000

1. What did you do this week?

After having decided to continue improving the pyqtgraph-prototype during the first week, I worked on implementing more features from the current RawBrowser as scrolling vertically through the channels and customizing the axes. An improved benchmark-utility allows now for comparison between different parameter-sets to observe the influence of parameters on the performance.

2. What is coming up next?

As the performance already has reached a satisfying level I decided with my mentors to focus on implementing the remaining features to see if everything is feasible with the pyqtgraph-backend.

3. Did you get stuck?

Sometimes it took me a while do understand how something like e.g. the axes are implemented in pyqtgraph, but the more I read the pyqtgraph-source-code the easier it gets.

Blog Week 1 (07.06.-12.06)

beetlejuice920@gmail.com (marsipu) — Mon, 14 Jun 2021 19:37:53 +0000

To implement the features of the existing Raw-Visualization and provide improved performance, Qt respectively PyQt was the backend-solution we pursued from the start. The Graphics View Framework from Qt provides the foundation for the required plotting-functionalities. Originally I thought I could read into the documentation of Qt alone and start with an (only) PyQt-based prototype from scratch. This turned out to be a big challenge, because there were various hurdles to overcome as how to setup the View, how to handle multiple Plot-Lines or how to setup axes. Thus on the second day I decided, in consultation with my mentors, to focus on the pyqtgraph-prototype which was planned to be setup during the second week for comparison. This turned out to be great, because by reading pyqtgraph's documentation and it's source-code I learned by example how a plotting-implementation in PyQt could be realized. The modularity of pyqtgraph and its well written code contributed significantly to my learning process (thanks and cudos @developers of pyqtgraph). I even got quickly to a point where the pyqtgraph-prototype could foreshadow to some extent how the final implementation may look like. So this week my work will also by focused on further improving this prototype to set the groundwork for the final backend.

Weekly Check-In Community Bonding Period (17.05.-06.06)

beetlejuice920@gmail.com (marsipu) — Mon, 07 Jun 2021 18:08:35 +0000

Introduction

Dear Python/MNE-Community, I am Martin Schulz (marsipu) from Heidelberg (Germany) and I am a 6th year student of medicine. When starting my thesis about pinprick-evoked pain (MEG/EEG) three years ago, I got first in touch with MNE-Python & Programming and benefited a lot from it since. Starting to contribute was an exciting “looking behind the curtain”-experience and therefore I am enthusiastic about the perspective of using this summer for full-time contribution.

My project is about providing an additional backend for the visualization of Raw-data. It is supposed to offer higher performance (e.g. regarding scrolling & scaling) and thus shall facilitate the analysis-step of signal inspection.

1. What did you do this week?

During the Community-Bonding-Period I met with my mentors and started to learn more about the current RawBrowser-Implementation by working on related issues (#9412, #9414, #9419, #9444). I also started reading into the documentation of some of the possible backend-alternatives (PyQt, pyqtgraph) and created my gsoc-repository where prototypes and progress will be hosted.

2. What is coming up next?

This first week of coding will be all about expanding the existing (only)pyqt-based prototype to be comparable to the other possible backends (pyqtgraph, vtk). In the course of that I will also probably start to refactor the prototypes to make their comparision in a future benchmark-utility easier.

3. Did you get stuck anywhere?

Learning about how Qt handles custom plots took (and still takes) me longer than expected and some problems of #9419 posed a challenge, but with the help of the other contributors/mentors those could be overcome.