GroIMP wiki - tutorials

a-beginners-tutorial

Anonymous (anonymous@undisclosed.example.com) — 2026-01-23T11:55:08+00:00

GroIMP: A Beginners Tutorial Gerhard Buck-Sorlin, Institut Agro Rennes-Angers Installing GroIMP and making yourself familiar with the platform Installing the platform GroIMP on your computer is actually quite straightforward if you carefully follow the instructions below. GroIMP runs on Java, so first of all, make sure you have a recent version of Java installed. To check if you have Java installed on your machine you open the command prompt window (type cmd in the search window), then type “…

advanced

Anonymous (anonymous@undisclosed.example.com) — 2025-11-05T09:18:24+00:00

Advanced tutorials This tutorials cover more specific features of GroIMP. There are many more example available in the gallery and within GroIMP. * Basic to advanced XL queries * Virtual Laser Scanner for GroIMP * How to use the ODE framework * How to create a video of a simulation * From light interception to photosynthesis: * How to use the radiation model within a crop model: Introducing light interception of leaves * How to use the radiation model within a crop model: Plo…

analyse-structure

Anonymous (anonymous@undisclosed.example.com) — 2025-06-30T14:51:32+00:00

Structural QSM-based data analysis integrating R Sometimes, you might want to conduct some statistical analysis on the structure of your simulated or measured plant outside of XL and GroIMP. GroIMP's query system is principally a very powerful tool for the data subsetting part of such analysis (finding parts of your structure that follow some topological relationships), but it can be hard to apply advanced statistical methods directly in GroIMP.

architecture-model

Anonymous (anonymous@undisclosed.example.com) — 2024-11-19T12:06:23+00:00

Growth models step by step In this tutorial we will create a growth model for a crown architecture. The model considers only the branch structure, without leaves, to provide an easy entry point. It may be helpful to understand the basic RGG code structure first, a tutorial is provided $l$

basic-spectral-light-modeling

Anonymous (anonymous@undisclosed.example.com) — 2025-06-07T04:21:33+00:00

Spectral Light Modelling These three core aspects of light simulation—global and local illumination models, and light sources—are the base for any light simulation. When it comes to spectral light simulations, specialized implementations of the aforementioned aspects are required, capable of simulating not only one or three light channels, as is typical for common light models, but also the entire light spectrum for different wavelengths.

basic-to-advanced-xl-queries

Anonymous (anonymous@undisclosed.example.com) — 2025-01-10T10:14:58+00:00

From simple to advanced XL queries This tutorial is more of a quiz than a tutorial, for the different type of queries a graph and a set of quests are provided. For each quest, the answer and an explanation is provided. Yet it is important to mention that there can be several solutions, for most of this problems.

colorbar-measuringstick

Anonymous (anonymous@undisclosed.example.com) — 2024-12-06T20:38:16+00:00

Color bars and measuring sticks Color bars and colour maps False colouring is a common tool, for instance, to visualize different light absorption, temperature distribution etc. The right choice of proper colour map can make the difference between a great intuitive understandable figure or just some usual plot. GroIMP provides for this purpose the ColorGradient class, in which several common colour maps are predefined. It further supports the definition of user-defined gradients and even diffe…

common_rewriting_rules

Anonymous (anonymous@undisclosed.example.com) — 2025-01-10T10:15:26+00:00

Structural rules L-System style Of the two structural rules this one is much more commonly used in GroIMP. It replaces each instance of the pattern defined on the left side with the new created graph structure on the right side. ==> ;

create-groimp-plugin

Anonymous (anonymous@undisclosed.example.com) — 2024-12-06T07:54:44+00:00

This tutorial aims at showing how to get started on GroIMP plugin development. It is assumed that you are able to compile the plugin using Maven (either the plugin alone, or the whole project). In this tutorial we are going to create a new plugin (from the empty template), add a new MimeType (format of file accepted by GroIMP) for import, and add a menu item that run a specific command.

create-interactive-tutorial

Anonymous (anonymous@undisclosed.example.com) — 2025-05-26T22:37:55+00:00

Create an Interactive tutorial Starting with GroIMP 2.1.7 it has become possible to create interactive tutorials to present panels and workflows. The interaction is based on GroIMP Layouts, the embedded HTML view and the tutorial navigation panel. Overall concept GroIMP Layouts describe the composition of the different panels in a project and can be saved using

create-parameternode-eso

Anonymous (anonymous@undisclosed.example.com) — 2025-01-08T18:11:35+00:00

In this tutorial we will create an amazing parameter node :)

custom_storing_node

Anonymous (anonymous@undisclosed.example.com) — 2025-11-25T10:58:50+00:00

Mistake: Storing Nodes outside of the graph When developing a complex model in GroIMP, it happens that you want to “store” nodes in an “easy” to access data structure (list, array, map, ...), or as fields of other objects (create a module with its parent as field). Such kind of development practice are strongly discouraged, as they are both inefficient and prone to unexpected errors in the project. This tutorial will cover what type of issues this behavior can create, and propose different appr…

dev

Anonymous (anonymous@undisclosed.example.com) — 2025-03-21T10:24:20+00:00

Development tutorials * Setup GroIMP with git and Eclipse * Setup GPUFlux for Eclipse * Adding a jEdit plugin * Create a GroIMP Plugin * Create new API functions * Create a interactive Tutorial

exercises_binary_ternary_tree

Anonymous (anonymous@undisclosed.example.com) — 2025-11-01T08:47:51+00:00

From binary to ternary tree Change the default 3d binary tree to a ternary version, a tree with tree instead of two branches. Solution public void run3() [ A(x) ==> F(x) [RH( 0) RU(45) RH(90) A(x*0.8)] // first branch [RH(120) RU(45) RH(90) A(x*0.8)] // second branch [RH(240) RU(45) RH(90) A(x*0.8)]; // third branch ]

exercises_binary_tree_3d2d

Anonymous (anonymous@undisclosed.example.com) — 2025-11-01T08:47:18+00:00

From 3D binary tree to 2D binary tree Change the default 3d binary tree to a 2d version, growing planar in one plane. Solution RU(90) public void run1() [ A(x) ==> F(x) [RU( 30) A(x*0.8)] // first branch [RU(-30) A(x*0.8)]; // second branch ]

exercises_plant_like_structures_abop

Anonymous (anonymous@undisclosed.example.com) — 2025-11-01T08:46:35+00:00

Implement 'plant like structures' Implement the 'plant like structures' as described in the book “The Algorithmic Beauty of Plants” by Prusinkiewicz and Lindenmayer (1990) on page 25 in Figure 1.24. Help In order to have a X (model d), e), and f)) that we can use, we first need to define it as module. For this a module without any parameters, extends, or instantiations is doing the job just fine. While we already have a

exercises_spirals

Anonymous (anonymous@undisclosed.example.com) — 2025-11-01T08:48:41+00:00

Generate some spirals Write some code to generate simple spirals. s1: a=50 degree, s=0.88 s2: a=80 degree, s=1.0 s3: a=120 degree, s=0.75 s4: a=145 degree, s=1.05 Play around with different angles and shrinking factors. Solution AA module A(float len); protected void init() [ Axiom ==> A(1); ] public void run()[ A(x) ==> F(x,0.05) RL(50) A(x*0.88); ]

export-object-from-groimp

Anonymous (anonymous@undisclosed.example.com) — 2025-11-01T09:16:38+00:00

Export Object The results of a simulation can be exported to different formats (including 3D and taxonomical). If we want for example export the new RGG tree as an obj (a simple 3d format), we just need to start a new rgg project and run it a couple of times (so there is actually anything to export).

first-steps-map

Anonymous (anonymous@undisclosed.example.com) — 2025-01-10T07:27:22+00:00

first-steps

Anonymous (anonymous@undisclosed.example.com) — 2025-12-05T09:07:55+00:00

Tutorials Here is a non exhaustive list of examples to get started with GroIMP. There are many more examples available in the gallery and within GroIMP. First steps * Use the GroIMP software (video tutorials) * A Beginners Tutorial * Running your first model * Introduction to RGG Code structure * XL queries and operators * XL turtle geometry * A step-by-step growth model * Create a simple tomato model * Light modelling * Introduction - A little bit of theory …

getting-started-with-grolink-and-gropy

Anonymous (anonymous@undisclosed.example.com) — 2025-06-16T15:00:36+00:00

Getting started with GroLink and GroPy To improve the usability of the API, the GroLink project includes a Python library, that links Python code to the running API server. Requirements * A GroIMP version including the API plugin is needed, the first version including the

getting-started-with-grolink-and-gror

Anonymous (anonymous@undisclosed.example.com) — 2025-06-16T15:00:50+00:00

Getting started with GroLink and GroR To improve the usability of the API, the GroLink project includes a R library, that links R code to the running API server. Requirements * A GroIMP version including the API plugin is needed, the first version including the

getting-started-with-grolink-and-http

Anonymous (anonymous@undisclosed.example.com) — 2025-07-02T07:27:48+00:00

Getting started with GroLink and HTTP To show the usage of the API without a client library this tutorial uses HTTP calls by just opening them in the webbrowser. This Tutorial shows only a limited functionality because HTML hyperlinks can not send a request body.

grogra-functions

Anonymous (anonymous@undisclosed.example.com) — 2025-06-30T14:44:32+00:00

GROGRA Functions for structural analysis GroIMP contains some of the functions from its predecessor GROGRA which can be used to statistically analyze the current structure (e.g. with regard to lengths, angles, ect.). These functions can be found under Panels

grolink-on-kubernetes

Anonymous (anonymous@undisclosed.example.com) — 2024-12-02T14:38:57+00:00

Deploying GroIMP/GroLink on Kubernetes This tutorial is a first step towards deploying GroIMP on a compute cluster. This at the moment is more of a prove of concept than a established way of using GroIMP. The idea is to have several multiple pods running the GroIMP

handeling-data-in-grolink-projects

Anonymous (anonymous@undisclosed.example.com) — 2024-04-15T12:34:28+00:00

Handeling data in GroLink Projects Many GroIMP projects use external data such as csv or xls files by linking these files in RGG code. This will (with the right path) work on the API in the same way. Except if the GroIMP and the API are executed on another device.

http_server

Anonymous (anonymous@undisclosed.example.com) — 2024-12-16T10:45:52+00:00

Getting started with GroIMPs HTTP-server GroIMP comes with an basic HTTP server that allows users to open projects from a given path. The server can also manage basic additional input and the return of values to the http client. In the following a brief start for this is given.

import_mtg

Anonymous (anonymous@undisclosed.example.com) — 2024-04-26T14:46:21+00:00

Import and Export Formats: MTG - Multiscale Tree Graph EXAMPLE - Importing and Using MTG data in GroIMP ---------- NOTE: In this example, a .mtg file is already imported and a .rgg file has already been added into the project. Begin at step 1 if you wish to find out how to load a .mtg file into GroIMP.

import-object-in-groimp

Anonymous (anonymous@undisclosed.example.com) — 2025-11-01T07:24:19+00:00

Importing objects With GroIMP it is possible to import objects from several 3d or graph formats into the project graph. The imported objects can then be used similarly to any other part of the graph. In the following, a different way of adding a file will be shown based on

interfaces

Anonymous (anonymous@undisclosed.example.com) — 2025-11-05T09:18:46+00:00

Additional interfaces Besides the Graphical user interface that is used in GroIMP by default, it is possible to execute models in other ways. The different User interface are described in the user-guide This can be useful for specific scenarios such as larger pipelines or remote execution. On this page you can find a collection of tutorials to get started with the different additional users interfaces.

jedit-plugins

Anonymous (anonymous@undisclosed.example.com) — 2024-04-15T10:28:29+00:00

JEdit plugins for GroIMP The embedded text editor jEdit has some additional plugins not included in the GroIMP version. They can be downloaded on the jEdit website. Integration in GroIMP To include a jEdit plugin in GroIMP you need to: * Download the plugin source code from the jEdit website.

leaf-triangulation

Anonymous (anonymous@undisclosed.example.com) — 2024-12-09T20:51:52+00:00

Leaf triangulation Triangulation is the process where a (ordered) set of triangles is generated out of a (unordered) set of points. The result is a set of triangles, now called faces, that can be directly drawn. Let's see the following set of 2D point:

light-modeling-differences

Anonymous (anonymous@undisclosed.example.com) — 2025-02-28T21:04:49+00:00

Differences between the CPU and GPU light model 1. Ordered List Item 2. Interpretation of specular and shininess reflection 3. Interpretation of transparency of image textures 4. Implementation of the GrinClonerNode behaviour * CPU (Twilight) implementation: repeats objects only into first quadrant

light-modeling-first-steps

Anonymous (anonymous@undisclosed.example.com) — 2025-11-01T19:22:57+00:00

First steps on light modelling This tutorial we show you the basics on how to do light modelling in GroIMP. For some more theoretical background pleas refer to the Introduction - A little bit of Theory page. For an advanced tutorial on spectral light modelling check out the Spectral light modelling tutorial.

light-modeling-introduction

Anonymous (anonymous@undisclosed.example.com) — 2025-06-02T17:58:37+00:00

General Introduction Rendering vs Light Modelling Rendering is the process of generating a (final) image (or a series of images) from a 3D scene. This includes computing how surfaces appear based on materials, lighting, camera position, and other visual effects.

light-modeling-light-shader

Anonymous (anonymous@undisclosed.example.com) — 2025-12-10T05:33:18+00:00

Local illumination - Shader To set the optical properties of an object, in computer graphics the so-called local illumination model is used. It defines so-called shaders, that are define the amount of absorption, reflection and transmission and how the light rays are scattered. The values for absorption are obtained as the 'remaining radiation', i.e., the difference between reflectance and transmission, when we subtract the reflectance and transmission from the total of incoming radiation: Abso…

light-modeling-light-sources

Anonymous (anonymous@undisclosed.example.com) — 2025-06-02T17:09:05+00:00

Light Sources Regarding light sources, GroIMP provides a complete set of possible implementations. They all implement the Light and LightBase interfaces, which makes them easy to handle and exchange. The standard light sources are: PointLight, SpotLight

light-modeling-lm-functions

Anonymous (anonymous@undisclosed.example.com) — 2025-05-24T13:46:06+00:00

More light model functions... beyond getAbsorbedPower So far, we only used the light model to obtain the amount of absorbed power for the objects within our scene, but there is more :) Note: The following is only implemented for the CPU-based twilight light model of GroIMP and NOT implemented for the GPU-based Flux light model.

light-modeling-sensors

Anonymous (anonymous@undisclosed.example.com) — 2025-11-02T02:59:00+00:00

Sensors Sensors or sensor nodes are invisible objects that can be used to monitor light distributions with a scene without interfering with the rest of the scene or the light modelling. For this, GroIMP provides the SensorNode class, a spherical object that can be placed arbitrarily within the scene. To obtain the sensed spectrum, the function

light-modeling-visualizing-light-rays

Anonymous (anonymous@undisclosed.example.com) — 2025-01-11T17:40:24+00:00

Visualizing light rays Sometimes it is interesting to see the traces of light rays emitted by a light source when they travel through a scene. In GroIMP, this can be done using the integrated LightModelVisualizer. To use it, all one needs to do is to add a

ode-framework

Anonymous (anonymous@undisclosed.example.com) — 2025-07-25T12:13:33+00:00

How to use the ODE framework Since GroIMP 1.0 a new ODE framework is available to modellers. This allows easy specification and solution of differential equations, which are used in many FSPMs. The key component of this framework is a new operator :'= called the deferred rate assignment operator. $y' = f(t,y),y(t0) = y0$$$ \begin{align} k_1 &= y_n+\tfrac{1}{6}\left(k_1+2k_2+2k_3+k_4 \right)\\ t_{n+1} &= t_n+h \end{align}$$ where $$ is the RK4 approximation of $$$ \begin{align} k_1 &= f(t_n,y_…

plotting-data

Anonymous (anonymous@undisclosed.example.com) — 2025-11-01T08:29:57+00:00

Datasets and Plots inside GroIMP GroIMP comes with an included management of dataset and the ability to visualize them, in the following only a small introduction is given. Datasets in RGG A datasets in GroIMP are simple tables, that can be referenced from RGG and the

point-cloud-tools-algorithms-and-math

Anonymous (anonymous@undisclosed.example.com) — 2024-11-11T11:20:14+00:00

Point Cloud Tools: Algorithms and Math Note: This is based on the plugins “PointCloud” and “PointCloud-Shapefitting” you get them through the Plugin manager. Because formulas can not be displayed here efficiently, we would recommend to read the belonging practical reports for more information about the math behind the point cloud features. In case of interest, please contact the GroIMP developer team.

point-cloud-tools-in-the-graphical-user-interface

Anonymous (anonymous@undisclosed.example.com) — 2024-04-15T12:46:53+00:00

Point Cloud Tools in the Graphical User Interface Note: This tutorial is based on the plugin “PointCloud” that you can get either through the Plugin manager (within Groimp) or by downloading the jar here. All features in this overview are available when a 3D project or an RGG project is opened in GroIMP. The functions work independently from XL scripts and are only based on the objects that are currently available in the 3D view.

point-cloud-tools-in-xl-and-headless-mode

Anonymous (anonymous@undisclosed.example.com) — 2024-04-15T12:53:54+00:00

Point Cloud Tools in XL and Headless Mode Note: This tutorial is based on the plugin “PointCloud” that you can get either through the Plugin manager (within Groimp) or by downloading the jar here. This overview contains the list of available java functions concerning point cloud import, clustering, splitting, merging, and export. They can be used in the java code (by future developers) and in XL code (by GroIMP users). They can also be used in headless mode. Parameters are always passed when t…

pointcloud-io

Anonymous (anonymous@undisclosed.example.com) — 2024-12-06T11:09:09+00:00

I/O Point Cloud The import formats both for files and object representation in GroIMP presented in this tutorial are mostly coming from the plugin Pointcloud. See here to see how install plugins in GroIMP. The wiki is up to date with the version 1.7 of the plugin.

radiation-model-in-crop_model

Anonymous (anonymous@undisclosed.example.com) — 2025-06-03T06:42:46+00:00

Introducing light interception of leaves Open the file [Light.gsz]. This is a simple model of a plant that will grow (produce new leaves and internodes) and branch, while each leaf intercepts light from a lamp hanging over it. One of the first things that come to mind when thinking about plant functions is, of course, photosynthesis. In order for the plant to do photosynthesis, it needs energy, water and CO

radiation-model-in-crop_model2

Anonymous (anonymous@undisclosed.example.com) — 2025-05-27T15:53:02+00:00

Plotting the absorbed light in a chart Open the file [lightchart.gsz]. We now want to see model output as a chart (as you might know from R). The total light intercepted by all leaves is output into a chart, and this at every step of the simulation. For this, we have to declare a kind of data table in which the output is stored:

radiation-model-in-crop_model3

Anonymous (anonymous@undisclosed.example.com) — 2025-05-27T15:55:35+00:00

Introducing leaf growth Open the file [LeafGrowth.gsz]. Currently, the leaves and internodes of our plant just “pop up” with their final size, although in a real plant they would, of course, grow. Growth in length can be modelled easily: first, we need to give both

radiation-model-in-crop_model4

Anonymous (anonymous@undisclosed.example.com) — 2025-05-27T15:58:04+00:00

Introducing absorbing tiles Open the file [Tiles.gsz]. We also want to visualize how much light is reaching the ground. To do that, we cover the soil surface around the plant with light-absorbing tiles. First of all, you need to declare a new module: // light absorbing tile module Tile(float len, float wid) extends Parallelogram(len, wid) { float al; };

radiation-model-in-crop_model5

Anonymous (anonymous@undisclosed.example.com) — 2025-10-29T20:39:09+00:00

Introducing simple linear leaf photosynthesis Open the file [simpleps.gsz]. We want to have some rudimentary photosynthesis. In its simplest version, the model of photosynthesis is simply a linear function of absorbed radiation. This approach is called Radiation Use Efficiency

radiation-model-in-crop_model6

Anonymous (anonymous@undisclosed.example.com) — 2025-05-28T22:47:40+00:00

More realistic non-linear photosynthesis Open the file [NLPS.gsz]. In this more realistic photosynthesis model, the rate of carbon fixation or carbon exchange is not directly linearly related to the light quantity but becomes saturated with increasing photosynthetic photon flux density:

radiation-model-in-crop_model7

Anonymous (anonymous@undisclosed.example.com) — 2025-11-02T07:33:29+00:00

Aging of flowers, and fruit formation Open [FlowerAging.gsz]. As you know flowers do not stay on the plant for a long time after blooming; in fact, they perish rather quickly and are dropped altogether or are replaced by a growing fruit after successful pollination. In our model, we can very simply introduce aging and dropping of flowers. First, the Flower requires two new parameters,

radiation-model-in-crop_model8

Anonymous (anonymous@undisclosed.example.com) — 2025-10-29T20:56:13+00:00

Dynamic crop model optimizing light interception and fruit yield Open [GrowManyFruits.gsz] This model produces a virtual plant canopy, initially consisting of 16 plants (four rows of four plants each). When you run the model, you will get the 3D visual output and also some curves (in the chart

radiation-model-in-crop_model9

Anonymous (anonymous@undisclosed.example.com) — 2025-11-01T14:40:03+00:00

Assimilate Transport and Fruit Development Open [Transport.gsz] The Transport model extends the Flower aging model by implementing a physiologically-based system for sugar transport from photosynthetically active leaves through the plant architecture to developing fruits. This creates a more realistic simulation of source-sink relationships in the virtual plant.

radiation-model-in-crop_model10

Anonymous (anonymous@undisclosed.example.com) — 2025-11-01T22:11:15+00:00

Source-sink model with central pool At the example of a sunflower model developed as a teaching tool at the Bachelor level, we will introduce here the coupling of the previously introduced photosynthesis model with a simple allocation model based on the central pool concept and redistribution of assimilates according to the relative sink strength method introduced by Leo Marcelis. You can find a presentation with details on the model

rgg-code-structure

Anonymous (anonymous@undisclosed.example.com) — 2025-10-21T10:04:09+00:00

RGG Code structure introduction The RGG programming language repents the core of almost all GroIMP models. This language extends java and implements the XL-language specification (), to enable rule based graph manipulation. This leads to a programming language based on two paradigms, the object orientation of java and the rule based structure of XL. In order to separate these two rgg is using different brackets to define code blocks. The java blocks ar…

sensitivity-analysis-using-grolink-and-gror

Anonymous (anonymous@undisclosed.example.com) — 2025-09-24T14:31:11+00:00

Sensitivity analysis on GroIMP models using GroR This wiki explains how to do a sensitivity analysis on GroIMP models using the GroR interface using a Morris screening over input parameters of the "Example08" FSPM model from the gallery as an example. Prerequisites Make sure to

sensor-grids

Anonymous (anonymous@undisclosed.example.com) — 2025-06-04T12:12:29+00:00

Sensor Grids and Areal Sensors Light distributions, micro-light climate, light above canopy, light extinction coefficients, etc. are key parameters for any canopy simulations. To obtain these, areal or gird like sensor arrangements are required. Both can be generated within GroIMP by only a few lines of code.

setup-gpuflux-for-eclipse

Anonymous (anonymous@undisclosed.example.com) — 2024-04-15T09:49:11+00:00

Setup GPUFlux for Eclipse Note that GroIMP IMP plugin should automatically handle the load and use of JOCL by default. So this tutorial is only to use if You want to load JOCL without IMP. After having checked out the GPUFlux project into Eclipse, you need to setup OpenCL for GPUFlux to build and run.

setup-groimp-dev-environment

Anonymous (anonymous@undisclosed.example.com) — 2024-12-18T09:55:48+00:00

Setup GroIMP with Git and Eclipse In this tutorial we will cover how to: * Use Git to download GroIMP source code * Use Maven to compile the code * Set up Eclipse as IDE You can find more in depth info on : * Download the source code * Set up Eclipse * Set up a Maven token * Additional commands with maven Installation of required tools

simple-tomato-model

Anonymous (anonymous@undisclosed.example.com) — 2024-12-07T15:02:56+00:00

A simple tomato plant model In this tutorial we will create a simple model of a tomato plant architecture. Preliminary steps We start a new project by opening a new RGG template model (File -> New -> RGG Project). The simple model that we are going to create will have the following structure:

spectral-light-modeling-architecture

Anonymous (anonymous@undisclosed.example.com) — 2025-06-01T15:45:23+00:00

Effect of spectral light on morphogenesis Open [SpectralLight.gsz] and explore the four files it consists of: Main.rgg, Modules.rgg, Parameters.rgg, and KL.java. The names already suggest that in Main.rgg you will find the main parts of the model, notably the methods

startup-api

Anonymous (anonymous@undisclosed.example.com) — 2025-01-22T14:55:45+00:00

Start GroIMP in API mode Using the GroIMP API it is possible to use GroIMP as a service, or from a remote server. Installing the API plugin The API can be installed using the plugin manager, to do so please go on help / plugin manager and select under available plugins the plugin

startup-cli-model

Anonymous (anonymous@undisclosed.example.com) — 2024-04-15T12:39:20+00:00

Start a model in CLI In this tutorial we will go through the creation, modification and basic interactions of a RGG project. Let's start by starting GroIMP in CLI with the command java -Xverify:none -jar core.jar --headless -a cli at the root of your GroIMP repository. You should see the terminal opening the application the logo of GroCLIMP, and the new prompt that display

startup-headless-model

Anonymous (anonymous@undisclosed.example.com) — 2025-06-03T10:26:52+00:00

Headless in GroIMP Find more information on the Headless implementation and functions here. Download example You can find an example here. Download the example project and run in with java -Xverify:none -jar core.jar --headless PATH/TO/THE/MODEL.gsz. The model will run in background, grow few steps of the plant model, and export several views for each step.

startup-model

Anonymous (anonymous@undisclosed.example.com) — 2025-11-03T00:50:41+00:00

Running your first RGG model Installation GroIMP is a Java-based application that supports Windows, Mac and Linux. Installation files can be found here. Before installing GroIMP, please make sure that you have Java 21 or higher installed on your computer. If not you can find the oracle version

tutorials

Anonymous (anonymous@undisclosed.example.com) — 2025-10-30T20:57:22+00:00

Tutorials Here is a non exhaustive list of examples to get started with GroIMP. There are many more example available in the gallery and within GroIMP. First steps * Use the GroIMP software (video tutorials) * Running your first model * introduction into RGG Code structure * Import an object in GroIMP * The GROGRA Functions for structural analysis * Rotating an object in GroIMP * Plotting data in a diagram Advanced tutorials * Virtual Laser Scanner for GroIMP * How to u…

use_fluxmodel

Anonymous (anonymous@undisclosed.example.com) — 2024-04-29T12:39:45+00:00

In this tutorial we will see how to get started with a FluxModel in GroIMP. Go here to see more about how the FluxModel is defined in GroIMP. Light Model First, we setup of the Flux Light Model: import de.grogra.gpuflux.tracer.FluxLightModelTracer.MeasureMode; import de.grogra.gpuflux.scene.experiment.Measurement; const int RAYS = 10000000; const int DEPTH = 10; const FluxLightModel LM = new FluxLightModel(RAYS, DEPTH); protected void init () { LM.setMeasureMode(MeasureMode.FULL_SPECTRUM)…

using-mesh-clouds-as-organ

Anonymous (anonymous@undisclosed.example.com) — 2025-11-01T23:21:02+00:00

Using a mesh cloud as a high resolution organ Idea This tutorial uses a [ply] file of a leaf with points and meshes to simulate a small branch. The leaf is transformed and added several times to a branch model, to simulate leaf growth and light absorption.

using-point-cloud-to-validate-model

Anonymous (anonymous@undisclosed.example.com) — 2024-11-06T14:42:19+00:00

Using a point cloud to validate a simulation Idea The idea is to take a point cloud of a measured tree and 'move it over' it on the simulated tree to see how similar the tree and the measurements are. In the following, the point cloud (shown in the figure below) has been artificially created and therefore fits the tree very well.

video-plugin

Anonymous (anonymous@undisclosed.example.com) — 2024-04-15T10:32:51+00:00

Creating a video of a simulation GroIMP comes with a video plugin that can create animation out of pictures taken from the 3D model. This includes automatically running RGG functions while taking pictures. Requirements The video plugin of GroIMP uses the free software

virtual_skeletonization

Anonymous (anonymous@undisclosed.example.com) — 2025-05-05T15:06:12+00:00

VR Skeletonization The plugin VRSkeletonization enables to build a graph that follow the branch/ successor pattern from 3d coordinates. The VRSkeletonizations are composed of any Node under the RGGRoot, linked by BRANCH and SUCCESSOR edges. The knowledge of the skeletonization is kept by VRSPoint. The VRSPoints define the start and end of the VRS structure.

virtual-laser-scanner

Anonymous (anonymous@undisclosed.example.com) — 2024-04-15T10:22:42+00:00

Virtual Laser Scanner Introduction The ”Scanner” is a module implementing a virtual laser scanning device. To use it, first import the module : " import de.grogra.rgg.Scanner ;" and create a new instance : " Scanner ls = new Scanner() ;" $\theta_{range}$$\phi_{range}$$\theta_{step}$$\phi_{step}$$\vec{x}, \vec{y}, \vec{z}$$\vec{x}, \vec{y}, \vec{z}$$\theta \in \left[\frac{-\theta_{range}}{2}, \frac{-\theta_{range}}{2}\right]$$\theta_{step}$$\phi \in \left[\frac{\pi}{2}-\frac{-\phi_{range}…

xl-queries-and-operators

Anonymous (anonymous@undisclosed.example.com) — 2025-11-01T02:44:14+00:00

XL queries and operators Queries Graph queries are used to analyse the actual structure (graph), which can be for example a plant structure. In XL, queries are enclosed in asterixed parentheses (* *). The elements in a query are given in their expected order, e.g.

xl-turtle-geometry

Anonymous (anonymous@undisclosed.example.com) — 2025-10-29T11:09:20+00:00

XL turtle geometry and graph construction This tutorial is only on the static construction of a 3D model and the underlying graph. There is nothing chaining and there are not steps involved. Therefor our base code structure only requires the init function:

xparametric-model

Anonymous (anonymous@undisclosed.example.com) — 2025-06-03T15:07:32+00:00

Forward parameters from the command line to a project It is possible to forward parameters from the command line to GroIMP using additional parameters beginning with an capital X.This parameters need to be added before other specifications such as --