The Integrated Analysis Platform
for high-throughput plant image analysis

The Integrated Analysis Platform (IAP) has been designed and developed to support the analysis of large-scale image data sets of different camera systems. It aims in bridging different data domains and in integrating different approaches to data analysis and post-processing.

The source code of IAP is available under the GNU public license from SourceForge (link).

If you have any question, feel free to the designer and developer of IAP by E-Mail.

Reference Information

Klukas, C., Chen, D., Pape, J.M.: Integrated analysis platform: An open-source information system for high-throughput plant phenotyping. Plant physiology 165(2), 506-518 (2014) (link)

Post-Processing High-Throughput Phenotyping Data

Our approach for post-processing phenotyping data has been published in The Plant Cell. Please click here, for further information and resources.

Outgoing Links

• Phenomics.cn collaboration
  

IAP on GitHub (!NEW RELEASE!) (sourcecode) and (new website)

Acknowledgements for funding

This work was supported by IPK institute funds, and with grants supporting collaborations and business trips from the National Natural Science Foundation of China (NSFC, 31050110121), the Robert Bosch Stiftung (32.5.8003.0116.0), the Federal Agency for Agriculture and Food (BEL, 15/12-13, 530-06.01-BiKo CHN) and project funding of the Federal Ministry of Education and Research (BMBF) (OPTIMAL: 0315958A, DPPN: 031A053B), and the EU funded project EPPN (Grant Agreement No. 284443).

Download and Installation

IAP is a Java based command line and GUI application which has been tested to properly run under Windows (7), Linux (Scientific Linux 6.4) and Mac (10.8, Mountain Lion). Other versions of these operating systems and even other operating systems, where at least Java V1.7 is available, may also work.

If you have problems during installation or operation of the system, feel free to contact the designer and developer of IAP (Dr. Christian Klukas) by mail at link.

System Requirements

Software Requirements

• 64-bit Java JRE or JDK V1.7 or higher (e.g. "JRE 7, x64/64-bit")
• Windows (XP - 8.1), Linux or Mac OS X

Input/Output Requirements

• Display resolution of at least 1024x768 pixel
• Keyboard
• Mouse/trackpad

Memory/Storage Requirements

• 4 GB RAM minimum (3 GB for IAP with -Xmx3g), 8 GB RAM recommended (-Xmx7g)
  
  

Downloads

After checking the system requirements, it is recommended to download the IAP user documentation and to follow the installation instructions, as described in the PDF: User documentation (1.6 MB, PDF format)

IAP binaries and startup-scripts for Windows, Linux and Mac: iap.zip (76 MB)

An extensive example data set is accessible for data browing or copying to the local system from within the application (pre-configured and included as a remote storage location at the start screen), see tab "Data Set" on this website for more details.

Maize Analysis

Experiment Setup

We provide a a complete data set, which includes a image series of 33 fernandez maize plants. An experiment overview is shown in table below. Temperature and humidity were chosen constant over the whole experiment time. The imaging starts 26 days after sowing. For the image acquisition we considering the visible (390-750 nm), fluorescence (520-750 nm) and near-infrared (1450-1550 nm) light-spectra, we also used a one and a four pot configuration. Images were acquired from the side and the top view, the zoom level changes two times during the experiment to capture more details (after day 29 and day 42).

Maize Example Data. The whole data set including the results is linked for browsing within IAP, download of ZIP file is recommended in case of low download speed.

The image and numeric results of the analysis are included in the example data set. The numeric results are also available as a separate download: .xlsx (right-click to save, includes example diagrams) / .csv (includes results for individual side angles).

Maize Manual Masurements (zip)

Experiment Property	Input	Result
Duration	9 weeks in the system, 2 weeks pre cultivation
Number of plants	33	←
Number of images	33798
Size	112 GB	8 GB
Number of angles	25 side, 1 top	←
Resolution visible (px)	2056 × 2454
Resolution fluorescence (px)	1038 × 1390
Resolution near-infrared (px)	254 × 320
Watering	see data set

Some remarks: The images have been taken during initialization phase of the system, in the mean time the quality of the NIR images has been improved (camera exchange), and certain disturbing elements have been covered. The provided analysis pipeline is not tuned to the biggest possible extend to the given photographs, as the current setup is slightly different to the example data.

Maize Analysis Pipeline

For getting a better understanding of the pipeline construction, we divided the analysis into 5 Steps. A detailed description is provided in the tab Workflows in the pdf-file for the maize analysis. The pipeline is defined in the file MaizePipeline.java.

Example Workflows

For the example workflow description for Maize data you can find the example dataset in the tab "Data Set", which is also available directly from the IAP start window, using the command button "Example Dataset". The manual download of a single ZIP file from SourceForge is recommended, in case the download of individual images is deemed too slow.

Maize Workflow 9 pages analysis of the example data set

Barley Workflow 28 pages includes description on usage of the DBImportExport tool

Arabidopsis Workflow 8 pages analysis of multi-well data sets

Optional extensions (Add-ons)

Detached Leaves and Scanned Roots analysis functions are part of the IAP example add-on which demonstrates how to integrate custom code to IAP. Details on how to develop your own functionality and how to package it as an Add-on are given in the tab "Development".


Within IAP click Start ▶ About ▶ Add-on Manager and then Find Add-ons/Updates to load the example add-on. More detailed instructions and screenshots for installation and usage of the add-on are provided in the workflow description documents:

Add-On Installation 3 pages includes description on how to install an Add-On

Detached Leaves 13 pages includes description on import of custom image data sets

Root Workflow 13 pages includes description on import of custom image data sets

Manual Download-Link

If the IAP-integrated download and install function does not work correctly (e.g. because of network/proxy problems), you may download the example add-on using this link. Within IAP click Start ▶ About ▶ Add-on Manager and then Install Add-on. Using the appearing file-browsing dialog locate the downloaded '.jar' file (IAPexampleAddOn.jar) and click OK to install the add-on.

Setup of Development Environment

The following procedure is suggested for setting up the development environment. First make sure that you have already installed the latest stable versions of Java and Eclipse. Then you can load the IAP source code from SourceForge. Download/Info-Links:

Java Software Development Kit (SDK) Java JDK 7

Eclipse Development Environment Eclipse

IAP Source Code on SourceForge Source Code

SVN Setup in Eclipse

To check out the project in Eclipse a SVN (Apache Subversion) interface is needed. If you have not yet installed an interface follow the next steps, otherwise go to the next section.

1. Run Eclipse and select Help > Install New Software... from the main menu.
2. On the dialog that appears, select a pre-configured simultaneous release update site in the Work with combo-box. For example (if you use "Juno") select the "Juno - http://download.eclipse.org/releases/juno" update site.
3. Wait a few seconds until the content of the selected update site is displayed under the combo-box.
4. Expand the Collaboration group and select the Subversive SVN Team Provider, then click finish to install.
5. After installation, agree to restart Eclipse.
6. Now, choose one of the Subversive SVN Connectors, which fits best to your system (we use the latest Kit version).

Project import into Eclipse

After finishing the installation make sure that you create a separate and clean Eclipse workspace. Then follow the next steps to import the project and configure the workspace:

1. First change the Text file encoding to UTF-8 (select Window > Preferences > General > Workspace, choose other and select UTF-8, then click OK)
2. Next, switch to the SVN Repository Exploring view and click on New Repository Location.
3. On the dialog that appears, copy this link svn://svn.code.sf.net/p/iapg2p/code/ into the URL field and click Finish.
4. Now a new Repository should appear in the SVN Repositories list, click right on it and choose Find/Check Out As ...
5. On the dialog that opens, choose the option Find projects in the children of the selected resource and click Finish. Now the download should start, this action takes some time.
6. Now switch to the Preferences menu again and go to Java > Code Style > Formatter and import the VANTED_SAVE_ACTION_FORMAT, you can find it under your workspace > make > save_action_format.xml.
7. Then (also in the Preferences menu) go to Java > Editor > Save Actions and enable all options.
8. After that, switch to the Java Perspective and navigate into the make folder.
9. Depending on your operating system execute the createfilelist, if you use windows just double click on the .bat file, for Unix or mac execute the .cmd file in the shell.
10. Now, you have to configure the Run configuration (click on the arrow beside the run icon), choose a name for the configuration, choose the IAP folder by clicking on the Browse button and then search for the main class.
11. Finally, switch to the Arguments tab and free up some additional main memory by adding -Xmx20g (in this example 20 GB, size of the allocated memory depends on your system, you should left some reserves for your operating system) to the VM arguments, then click Run. Congrats, the IAP should start!

Normally, there should be no errors in the Problems view, warnings can be ignored. If you have further questions, please write a mail.

Happy coding!

Short introduction into IAP extension development

IAP can be customized by the end-user with new data storage locations, accessible via FTP, SFTP, direct file system access (e.g. a local folder or mounted network drive), HTTP and SMB file share protocol. Pipeline blocks may be arranged in templates, blocks can be removed, added and the block settings, which modify the behavior of a analysis block, may easily be changed. Resulting custom templates can be exported, applied to other experiments and shared to other users. The end-user documentation (link) contains detailed infos on how to achieve these tasks. To add new segmentation, analysis functions or custom user commands, e.g. for export of data in a certain file format or for custom post-processing, new source code can be developed and easily integrated into IAP using the supplied extension API. The extension API is defined in the interface IAPplugin. This file defines all possible extension points for a user-defined IAP-Plugin.

Development of custom Analysis-Pipelines

If you plan to develop and use custom analysis pipelines, including new Analysis blocks, it may be a good idea not to customize the analysis templates from the "Setting>[Template]" editor. But to define the content of the template inside a custom Plugin, which will define the pipeline content and the custom analysis pipeline blocks. IAP already contains a plugin, for the definition of the Maize, Barley and Arabidopsis pipelines. The class PluginIAPanalyisTemplates forms a IAP plugin, which extends the system with 3 new analysis pipelines. Each pipeline definition is defined as an object implementing the interface AnalysisPipelineTemplate. A custom pipeline needs to implement the methods defined in the interface. For example the name of the pipeline and the list of blocks needs to be defined, as shown in the supplied maize analysis pipeline class: MaizePipeline. To let IAP load the new plugin, a XML plugin description file (example) needs to be created as described in the section "Adding new plugins to IAP" (below).

Development of new Analysis-Pipelines-Blocks

IAP contains a number of pre-configured analysis blocks, which are used for the definition of the provided analysis pipelines. In order to utilize new and advanced image segmentation techniques of to extract new traits, it is possible to quite easily extend the system with your custom analysis code. Such new Analysis block needs to implement the basis interface ImageAnalysisBlock.

Processing a image from a certain camera types

As not every analysis block needs to customize all aspects of such block, and may not need to process all input images from all possible camera types, it is a good idea to base a new block on the provided abstract class AbstractBlock. If you base your custom block on this task, it is only required to implement the method "Image processMask(Image mask) { ... }". This method is called by IAP once the previous piepline blocks have been executed, and the given mask-Image may be interpreted or modified by your code and then returned as a result. The camera type of the given image may be checked using the method "getCameraType()". To process the given image, you may access some build-in processing functions, by calling the method "io()", which returnes the so-called ImageOperation-object. Using this object you may easily invoke a list of standard-commands such as "rotate", "resize", "sharpen", "removeSmallElements", and many more. Each method in this class returns a new ImageOperation object, also containing the processed image result. This way, you can easily connect multiple processing calls, and finally call "getImage()", which can be returned in the analysis block. The Image class as well as the ImageOperation class contain the method "getAsImgePlus()", which returns the image as a ImageJ image object. As ImageJ is embedded into the application you may this way easily use methods or approaches, applicable to ImageJ within IAP.

Processing images from different camera types at the same time

If you would like to process or overlay images from different camera types (from a single snapshot), you should not base your image analysis block on abstract class AbstractBlock, but instead on the abstract class AbstractSnapshotAnalysisBlock. This base class helps you developing image analysis blocks, which may process images from all available camera types in a single step. For that you may implement and override the method "prepare()". Call "input().images()" or "input().masks()" to access main images or processed images within this method. You may also individually process the images of a certain camera type, by implementing the methods "processVISmask", processFLUOmask", ....

End-User Customization (Settings)

If you base your custom analysis block on any of the provided abstract classes, and not on the raw interface, you have access to automatically created settings. You may call the methods "int getInt(String setting, int defaultValue)", "int getDouble(String setting, double defaultValue)", "int getBoolean(String setting, boolean defaultValue)", to very easily make your code dynamic, according to user-provided changes to these settings. You need to specifiy default values for a particular settings, and the settings title. E.g. you could provide the user with the possibility to ommit a certain processing step by adding the following to your code: "if (getBoolean("blur image", true)) { ... }". By default the code will be executed, but if the user changes the newly appearing setting "blur image", the code will not be executed. You are free to name your settings as you will, but you should not use special non-ascii characters or other special formatting characters. After the first execution of a certain pipeline, the pipeline will be extended and include settings (accessible to the user as described in the end-user documentation), which may be easily changed to the particular situation. All settings are categorized according the the name of the analysis block. If you include your analysis block several times in a pipeline, all blocks will share the same settings. IAP also automatically creates separate settings for side- and top-images. In addition, the user may modify the behavior so that different settings are used for early or late time points or for different camera configurations. In all of these cases initially your defined default values are used.

Creating the plugin for the definition of the new analysis blocks

You need to extend your plugin definition class (implementing IAPplugin or better extending the abstract class AbstractIAPplugin) and override the method "ImageAnalysisBlock[] getImageAnalysisBlocks(). Also, the new plugin needs to be added to the list of known plugins as described in the section "dding new plugins to IAP" (below).

Development of new Command Buttons

You may add custom or new command buttons at several places inside IAP, e.g. at the Start-screen, as a command button, visible once an experiment has been opened, or within the Tools-section of a particular experiment. A detailed description on how to implement and add such new command buttons will be added to this website in the future. For now it may be best to check the existing source code and if unclear points exist, to ask the developers of IAP for help.

Adding new plugins to IAP

Once a new Plugin has been defined, IAP will only load it, if is known to the system. IAP uses a list of text files (plugin1.txt, plugin2.txt, plugins3.txt, plugins4.txt and pluginsIAP.txt). These text files need initially be created, before the first run of the application. And these text files need to be updated, once a new plugin has been defined. The scripts "createfilelist.bat" (Windows) and "createfilelist.cmd" (Linux/Mac), will create or update these text files. Each line is these text file contains the link (relative path and filename) to a Plugin description file in XML form. These plugin files contain information about the defined plugin. It is probably best to copy and adapt a existing plugin description file and modify its content (most importantly the class name of the plugin). The content of the xml file is self-evident. For example the analysis pipeline plugin description file looks like this: pluginIAPanalysisTemplates.xml.

Development of Add-ons

As IAP uses VANTED as one of its core libraries, custom plugins may be packaged into a single Jar file, which can easily be distributed and loaded by the end-users. Such Add-ons may customize the behavior of the included VANTED functionality and also of the new image analysis processing commands. The list of Add-ons (tab "Add-ons" on this page) gives an impression on the possibilities. Please refer to the Eclipse Project "IAP-Addon-Example" and use this as an template for your own developments. Check the content of the file IAPexamplAddOn.xml and modify the meta data (description of the Add-on) as needed. The createAdd-on.xml file is an Ant-Script (right-click it within Eclipse), which is used to pacakge the project content into a single JAR file, which can be loaded as an IAP Add-on. The Add-on is essentially a packages Plug-in, developed as described before on this page. The Plugin-description-XML file needs to be placed in the root of the source code folder. And the final JAR file name needs to be the same as the XML description file (ignoring the file extension). If you have developed your Block/Pipeline or Plugin and have problems in packaging it in a working Add-on, dont hesitate to contact the authors of the sytem

IAP - The Integrated Analysis Platform

Developed from 2010-03.2015 at IPK Gatersleben by the Group Image Analysis

Software design and main development: C. Klukas (head of group) Pipeline development: J.-M. Pape Post-processing: D. Chen

Development history

The Integrated Analysis Platform (IAP) has been developed by the IPK research group "image analysis" from May 2010-March 2015. The software design and architecture has been developed and implemented by C. Klukas. The image analysis pipeline development has been supported by J.M. Pape as part of his work for his Bachelor and Masters thesis.

IAP (2010-2015) uses VANTED (implemented in 2003-2010 as part of my PhD work, link) as a core library as well as ImageJ (link) for some of basic image analysis functions. VANTED itself is based on Gravisto (2001-2005, link).

Disclaimer of Warranties

You acknowledge and agree that the use of IAP is at your sole risk and that the entire risk as to satisfactory quality, performance, accuracy and effort is with you. It can not be guaranteed, that the functions contained in this software will meet your requirements, that the operation of IAP will be uninterrupted or error-free, or that defects in the software will be corrected.

The libraries, listed inside IAP, as you click 'About ▶ Library licenses', where used during the development of IAP. By using IAP you need to accept and be aware of the terms and conditions of these licenses.