It’s a while ago that I wrote about supervised image classification combining ImageJ and R in Bio7 (see video here). Later I decided to create a classification Graphical User Interface for Bio7 to make this process easier and implement typical functions for convenience.
However it took some time to finish a first version of this plugin and also to create a first documentation – working on it when I had some time to spare.
Click on the screenshot below to see a video on YouTube:
The plugin uses mainly the Java API of ImageJ to load, transform and filter images for a feature stack and transfer ROI (Region Of Interest) selections of this stack (pixel values) to R to train and classify the data with dedicated R scripts. The GUI itself reuses a powerful ImageJ component to collect selections (ROI Manager) and is embedded in a flexible view container (can be dragged around and detached).
Until now the plugin supports several datatypes, conversions, filters (features) and a GUI to apply a trained R classifier on multiple selected images or directories with the selected features easily.
The simple R scripts which can be executed from the GUI are using by default the randomForest package to train and classify the images. Automatically the classified results are transferred back to ImageJ for visualization and post-processing, e.g., object detection or particle analysis.
For a reproducible workflow all selections (using ROI Manager methods) and current GUI settings can be saved, e.g., for classification workflows of different tasks (cell detection, landscape analysis, etc.).
The plugin itself can be downloaded and installed via Github (e.g., using the Eclipse EGit plugin) and then compiled dynamically. Later it will be shipped with the upcoming Bio7 3.2 release.
At all the plugin is concepted in that way that it can be extended easily (extending the GUI interface using, e.g., the free Eclipse WindowBuilder plugin or simply extending the R scripts).
I tried to hold the source compact, as easy as possible and as complex as necessary.
The installation details and documentation can be found on the dedicated Github page:
A new release of Bio7 is available. This update comes with a plethora of new features, improvements and bugfixes.
R ImageJ Analysis Perspective (MacOSX Catalina, Dark Mode)
For those who don’t know Bio7. The application Bio7 is an integrated development environment for ecological modeling, scientific image analysis and statistical analysis.
It also contains a feature complete development environment for R with an advanced R editor, R developer tools and interfaces to perform scientific image analysis with R and the also embedded ImageJ application.
New and Noteworthy
General:
Bio7 3.1 RCP (Rich Client Platform) built upon Eclipse 4.14
New main toolbar action available to create different projects and files in one shot
Added a toolbar submenu action to open the ‘Control’ view
‘Dark Mode’ theme automatically enabled on supported OS (MacOSX only!)
‘2D’ perspective (e.g., for cellular automata simulations) is now hidden by default.
Removed the ‘Image’ perspective and the ‘Points Panel’ view and actions
Updated libraries (SSH for Windows, etc.)
Improved the ‘WorldWind’, ‘2D’ and ‘3D’ perspective to open and arrange the editor area in a user-friendly programming layout by default (see screenshots below).
WorldWind Perspective with opened Java file (MacOSX Catalina, Dark Mode)
2D Perspective with opened Java file (MacOSX Catalina, Dark Mode)
JavaFX has been disabled by default in the preferences for Linux HighDPI displays (e.g., GTK scale 2) because of an open bug when embedded in an SWT canvas.
Improved the default Bio7 CSS interface colors
R:
New toolbar wizard to create quickly R, R Markdown and Shiny files in a project
New R Packages tab available to show and update installed R packages (see screenshot below)
Load Packages Tab (MacOSX Catalina, Dark Mode)
Changed the ‘Image-Methods’ view to show only R/ImageJ related actions (bidirectional transfer of image data, selection data, particle and cluster methods, etc.)
Added the ‘Geometry Selections’ view to the ‘R ImageJ Analysis’ perspective to transfer ROI selection coordinates as a list or georeferenced data geometries (using package ‘sp’ and Java GDAL)
Added the KMeans cluster algorithm to the ‘Cluster Pic’ action in the ‘Image-Methods’ view
The ‘R ImageJ Analysis’ perspective is now visible by default
Improved the ‘Pixel RM’ and ‘Pixel RM Stack’ action to transfer all ROI selections more efficiently, especially for VirtualStacks of ImageJ
Added a new option in the ‘Pixel RM’ and ‘Pixel RM Stack’ action to transfer ROI Manager selections signature names according to a separator char (handy for supervised classification with ImageJ and R)
Added a new stack transfer API method (‘imageFeatureStackToR’) to transfer whole stacks in a column layout (for pixel classification)
The ‘R-Shell’ view list now scrolls to the last selected variables after a workspace refresh
New R editor ‘Quickfixes’ available (warning for an assignment operator in function call, check for null and na in comparison operators)
Improved the code completion of the ‘R-Shell’ view and the R editor
Improved the plot layout in ImageJ (when using the preference option ‘ImageJ View Display Size’ in the Rserve plot preferences)
Added a Shiny timeout to improve the server startup
Dynamic compilation now supports Java 13 by default
Added a new option to dynamically compile a class without a constructor call (without object creation). The object has to be created in the main method (as known from Java).
Fixed the OpenGL view visibility on MacOSX (the ‘3D’ and ‘WorldWind’ view stayed visible when switching to another perspective)
Added an experimental fullscreen option to open WorldWind and the ‘3D’ view on a secondary monitor (press F3)
Updated Java libraries
Download and Installation:
Windows:
Just download the *.zip distribution file from https://bio7.org and unzip it in your preferred location. Bio7 comes bundled with a Java Runtime Environment, R and Rserve distribution and works out of the box.
Linux:
Download and extract the installation file from https://bio7.org.
For Linux you have to install R and Rserve (see Rserve installation below!).
MacOSX:
Download and extract the installation file from https://bio7.org.
If you start Bio7 a warning or error can occur because of the changes how Apple treats signatures! To allow Bio7 to start see this instructions for Yosemite, Sierra and Mojave:
First try to open the app with the context menu to allow the execution. If that won’t work try the following:
In addition for MacOSX you have to install R and Rserve (see below!).
Linux and MacOSX Rserve (compiled for cooperative mode) installation:
To install Rserve open the ‘Native R’ console in the ‘Console’ view and then execute the view menu action “Options -> Install Rserve (coop. mode) for R …” for different R versions (SSL 1.1 version for Linux Ubuntu > 19.10). This will download and install Rserve in your default R library location, see video below (please make sure that your default Linux R library install location has writing permissions!):
In cooperative mode only one connection at a time is allowed (which we want for this Desktop appl.) and all subsequent connections share the same namespace (default on Windows)!
Bio7 Documentation
For more information about Bio7 please consult the soon updated Bio7 User Guide.
A plethora of Bio7 videotutorials for an introduction can be found on YouTube.
Bio7 can be extended with R packages, Eclipse plugins and ImageJ plugins. Another very easy option to extend the Bio7 Graphical User Interface with R actions are dynamic menus which can be used, e.g., for personalized workflows or repeating tasks. The provision of new menus and nested menus is simple and can be arranged for different tasks.
Three different menu locations can be populated with custom scripts. One location is the context menu of the R-Shell view.
To extend the R-Shell context menu scripts have to be copied to a default script location of the Bio7 installation. Folders in the locations constitute a new submenu, nested folders results in nested submenus. It is not necessary to restart the application because the menus are updated automatically and copied scripts are instantly available as an executable action
Executable R scripts in a menu can be used for instance to offer different plot actions (there is a special hidden vector variable available ‘.r_shell_vars‘ to get multiple selected objects, e.g., to plot a selected variable (without the need to use a Java to R API!):
plot(get(.r_shell_vars[[1]]))
In addition the different default script locations can be changed in the preferences. This is handy if you want to share scripts in a team using, e.g., GIT for updates and reproducibility. For Bio7 you can install the Eclipse GIT plugin (Menu: Help->Install New Software, Select ‘Eclipse Repository’, search for ‘git’, select and install ‘Git integration for Eclipse’) to share a local script folder on GitLab, Github, Bitbucket, etc.
A short overview how to create custom menus in the R-Shell context menu is demonstrated in the video below:
Please note that the menus can also be extended with JVM script types which run on the JVM (Java, Jython, Groovy, BeanShell, JavaScript, ImageJ Macro). If a custom interface should be created a selected JVM language can be used to create custom views and populate a special custom perspective. Special API functions for the interaction of Java and R are available, too.
An example how to build and invoke a custom interface with Java SWT is shown in the video below (a pure Java example installing and using the WindowBuilder plugin):
A new release of Bio7 is available which is built upon Eclipse 4.11 and the latest Java OpenJDK. This new version comes bundled with OpenJDK 12, supports the dynamic compilation of Java 11 and fixes several annoying bugs on MacOSX (e.g., shutdown crashes).
The R interface has been improved and the R-Shell now updates the workspace display automatically after a R code evaluation or R data transfer.
In additon for Bio7 3.0 the themes have been improved (especially for MacOSX and the Mojave dark mode) and some Touch Bar actions for MacOSX are available, too (if the MacOSX device has a Touch Bar).
Screenshots:
Screenshot MacOSX Mojave (dark mode)
Screenshot Linux Ubuntu 18.10:
Release Notes:
General:
Built upon OpenJDK 12 and Eclipse 4.11
Bundled with OpenJDK 12
Improved script menus
Touch Bar actions for MacOSX devices when a Touch Bar is available (can be enabled in the Bio7 preferences)
Image perspective is now hidden by default (we have already the ImageJ edit perspective)
Updated SSH executables for Windows
Multiple Images and PDF files can now be opened from without a lost focus
R:
Windows version bundled with R 3.5.3 and Rserve
R-Shell displays objects after evaluation
More default scripts in the R-Shell scripts menu (PyRserve, Install Rserve, etc.)
R-Shell visual improvements (line height of code completion – see preferences)
Added Touch Bar actions for MacOSX (can be enabled in the preferences)
Clipboard code evaluation improved
Improved browser selection for rmarkdown, knitr, R help, etc.
Improved text search speed for package installation search (MacOSX)
Java
Dynamic compilation of Java 11 supported
Added support for Java modules in the preferences (if necessary)
Added support for add-on libraries as installable plugins (OSGI)
*.java or *.class files can be put in the scripts menu for compilation (*.java) or execution (*.class)
Added support to compile Java files on the ImageJ classpath (which is a seperated OSGI classpath) to compile ImageJ plugins with dependent *.jars
High dpi scaling for Java Swing and AWT available if configured in the Bio7.ini file (-Dsun.java2d.uiScale=2.0 for high dpi displays)
Updated JOGL to version 2.3.2 with custom fixes
Changed the 3D interfaces (WorldWind, 3d) to the faster NEWT interface.
Table:
Excel export now exports all opened tabs as sheets in one file
Images in cells are now exported in excel files, too (anchored at cells)
Improved scripts menu
ImageJ:
Huge amount of changes since the last release. For all changes, see:
Just download the *.zip distribution file from https://bio7.org and unzip it in your preferred location. Bio7 comes bundled with a Java Runtime Environment, R and Rserve distribution and works out of the box.
Linux:
Download and extract the installation file from https://bio7.org. For Linux you have to install R and Rserve (see Rserve installation below!).
MacOSX:
Download and extract the installation file from https://bio7.org.
If you start Bio7 a warning or error can occur because of the changes how Apple treats signatures! To allow Bio7 to start see this instructions for Yosemite, Sierra and Mojave:
In addition for MacOSX you have to install R and Rserve (see below!).
Linux and MacOSX Rserve (compiled for cooperative mode) installation:
To install Rserve open the R shell and then execute the menu action “Options -> Install Rserve (coop. mode) for R …” for different R versions. This will download an install Rserve in your default R library location, see video below (please make sure that your default Linux R library install location has writing permissions!). In cooperative mode only one connection at a time is allowed (which we want for this Desktop appl.) and all subsequent connections share the same namespace (default on Windows)!
Recently I discovered the package PyRserve for Python which connects Python with R using Rserve.
This is extremly useful because Bio7 already integrates Rserve and has special GUI interfaces available to transfer, e.g., data from spreadsheets, ImageJ image and selection data (also georeferenced), Java simulation data, etc.
With this new Rserve connection this data can now easily transferred from Java and R to a Python workflow.
Python as a language is already supported in Bio7 with an integration of Jython (which runs on the Java platform a supported JVM language like Groovy, JavaScript, Scala, etc. and has a direct access to the Bio7 API).
In additon native Python can be executed with the default Bio7 Python editor if configured in the native preferences of Bio7 (running as an external process in a Bio7 Python shell if enabled).
However since Bio7 is based on Eclipse a more powerful editor for Python/Jython can be installed with PyDev which is a complete Python IDE for Eclipse and available as an Eclipse plugin which can be installed with the Bio7 (Eclipse) Update Manager
If PyDev is installed you can create Python projects in Bio7 and execute Python and Jython scripts depending on the settings in it’s own process (e.g. with the action editor context menu-> Run As->Python Run) .
In addition it is possible to use a special Bio7 toolbar action (visible if the PyDev editor or Bio7 Python editor is opened) to interpret the content of the PyDev editor in the current Bio7 Jython or Python process (which is of no importance for the following use of PyRserve!).
PyRserve can be installed easily using the pip command in the python shell:
However since the Bio7 functionality can be easily extended with scripts (which can be added dynamically to a menu copying them to a special scripts location, see screenshot below) I decided to write two short Groovy scripts to start and stop Rserve not controlled by the Bio7 Java connection interface (and if necessary disconnect R from a current Bio7 controlled Java connection).
The ‘Start_PyRserve’ script starts R and Rserve if not alive in the Bio7 R console and also disconnects from a running Java Rserve connection if activated.
Note that in Bio7 only one connection to Rserve is allowed (Rserve cooperative mode).
The ‘Stop_PyRserve’ script reconnects Python (closed in the Python scripts!) to shutdown Rserve and returns to the Bio7 console and R (Pydev has it’s own console).
This shutdown command is excecuted by an external Python process. To get the path for the Python interpreter we also have to set the Bio7 Python path (not PyDev!) in the Bio7 preferences (see Windows screenshot below – normally not necessary on Linux or when the Python interpreter is on the OS PATH!).
With this two scripts it is now (more secure) possible to start Rserve and use the Bio7 Java interface, e.g., to transfer image data to R (ImageJ to R), start the Python connection (which disconnects Java) and use the image data inside a Python workflow (see the second example).
Here a first example script to transfer random numbers (in PyDev use the context menu action ‘Runs As->Python Run’ of the editor to execute the Python script) with a PyRserve connection.
import pyRserve import matplotlib.pylab as pltconn = pyRserve.connect()matrix = conn.eval("tryCatch({matrix<-imageMatrix}, error = function(e) {return ('NULL')})")conn.close()if matrix != 'NULL': # we have to transpose the image for a correct view! matrix = matrix.T plt.imshow(matrix) plt.colorbar() plt.show()
Here a summary of the installation and configuration steps necessary for Bio7 to use PyRserve and execute Python scripts with the powerful PyDev editor:
Install the PyDev editor and configure the Python path
Install PyRserve (pip install PyRserve)
Configure the Python path of Bio7 (Preferences Bio7->Preferences Native)
Install the Groovy Start/Stop scripts for PyRserve (simply unzip Examples_PyRserve.zip in one scripts location – Open ‘Scripts->General->Open_Script_Location’ from the main Bio7 menu or in the context menu of the R-Shell view open General->Open_Script_Location’. Put them in an extra folder for a submenu!
Start the ‘Start_PyRserve’ script to start Rserve (not Bio7 controlled!)
Execute a Python script which connects and disconnects PyRserve
Stop the server and shutdown Rserve with the ‘Stop_PyRserve’ script
We use cookies to ensure that we give you the best experience on our website. If you continue to use this site we will assume that you are happy with it.OkNo
