Light modelling generally involves three aspects:

• Global illumination model
• Light sources
• Local illumination model

Whereas the Global illumination model handles the actual light computation, the Light sources are the light-emitting elements, and the Local illumination model defines the optical properties of the scene objects.

In each aspect, computer graphics offers plenty of alternatives.

Several of them are implemented in GroIMP as ready-to-use tools.

GroIMP integrates two two main light model implementations, namely:

• Twilight, a CPU-based implementation
• GPUFlux, a GPU-based implementation

Both implementing different global illumination model for rendering and for light computation.

In the following, only light computation or light modelling will be discussed.

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.

For the Local illumination model, which defines the optical properties of the scene objects such as values for absorption, transmission, and reflection, so-called shaders are used.

GroIMP provides a set of standard shader implementations, e.g., for Lambert and Phong shading. Whereas the Lambertian model supports only diffuse reflection, the Phong reflection model (B.T. Phong, 1973) combines ambient, diffuse, and specular light reflections.

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.

Note: The hardware requirement for performing GPU-based ray tracing is a programmable graphics card with OpenCL support. For example, any Nvidia card will do well, whereas older versions of integrated Intel cards—as they are often used in laptops—are not suitable for this. GPUFlux supports multiple GPU units and CPUs working in parallel at the same time. The use of multiple devices as well as the use of the CPU needs to be activated within the Preferences of the Flux renderer; see image below.

Spectral light simulations now deal not only with the pure calculation of light distributions but also include aspects of the principal characteristics of light, i.e., light quality, quantity, and duration.

The main factor influencing the light quality is the light's spectral composition, commonly called colour. Thus, the compositions of different intensities of different wavelengths form the final light spectrum or colour. Below are the light spectra of typical sunlight, of common HPS lamps (high-pressure sodium lamps), as used for instance as additional light sources within greenhouses, and a red LED lamp.

In GroIMP, the GPUFlux model allows us to simulate spectral light between 380 and 720 nm (default values).

Note: The implementation essentially allows setting individual limits for min and maxLambda, extending the range of the visible light spectrum to include infra-red and ultra-violet. When the wavelength deviates significantly from visible light, ray optics is no longer the most adequate tool for describing the flow of electromagnetic radiation, as other effects become significant. Therefore, from a physical point of view, the results will no longer be meaningful. One reason for this choice—the default range of 380-720 nm—is that the model uses Smith's conversion from RGB colours to full spectra. This conversion assumes that the whole spectrum is somewhat covered by the RGB colour, thus restricting the spectrum to the visual range. But if your model uses only spectral colours as inputs, then the interval could safely be extended.

The spectral range [minLambda, maxLambda] can be divided into a user-defined number of equally-sized so-called buckets—sub-channels. They can be one, taking the whole range as one channel—which, in my opinion, would not make much sense—or can be as large as the number of integer wavelengths of the range, leading to 1 nm buckets if desired. Common numbers of buckets range from 5 to 30, but this totally depends on the application. Below is an example of a 380-720 nm spectrum divided into 20 buckets, each with a 17 nm range.

Setting up the GPUFlux light model within GroIMP, or more accurately XL, follows the typical Java conventions of importing the required classes, and initializing and parameterizing the light model.

import de.grogra.imp3d.spectral.IrregularSpectralCurve;
import de.grogra.ray.physics.Spectrum;
import de.grogra.gpuflux.tracer.FluxLightModelTracer.MeasureMode;
import de.grogra.gpuflux.scene.experiment.Measurement;
...
 
const int RAYS = 10000000; //number of simulated light rays
const int DEPTH = 10; //maxiaml recursion/reflection depth
const FluxLightModel LM = new FluxLightModel(RAYS, DEPTH);
 
protected void calculateLight() {
 
    LM.setMeasureMode(MeasureMode.FULL_SPECTRUM); // actual the default value
    LM.setSpectralBuckets(21); // get 20 buckets; set to N+1 to get N
    LM.setSpectralDomain(380, 720); // default settings too
}

The GPUFlux light model supports three different modes of measuring spectral power:

• regular RGB, which simulates only three buckets approximating the three colour channels
• fully discretized spectral measurements, the default mode, simulating spectral light
• weighted integration, a weighted version of the spectral light simulation

mode ∈ {RGB, FULL_SPECTRUM, INTEGRATED_SPECTRUM}

The GPUFlux light model allows the following additional settings to control specifics:

// sets the maximum negligible power quantum
LM.setCutoffPower(0.01); // default: 0.001
 
// disables the simulation of sensor
LM.setEnableSensors(false); // default: true
 
// sets the random seed for the random number generator; us this to obtain reproducible results
LM.setRandomseed(123456);
 
// disables dispersion
LM.setDispersion(false); // default: true

After the light model is configured, it can be invoked by calling the compute() function as follows:

LM.compute();

To obtain the total amount of absorbed radiation of a node x, the getAbsorbedPowerMeasurement function of the light model needs to be called. The returned measurement object contains the results for the specific object x. By calling the integrate() function, the integral, or simply sum, will be calculated.

Measurement spectrum = LM.getAbsorbedPowerMeasurement(x);
float absorbedPower = spectrum.integrate();

By doing this within a rule, the light absorption can be obtained for all objects of the specified type, such as a Box, as in this example:

[
    x:Box ::> {
        Measurement spectrum = LM.getAbsorbedPowerMeasurement(x);
        float absorbedPower = spectrum.integrate();
    }
]

Accessing the absorption values for each bucket can be done by accessing the data variable of the Measurement class.

    Measurement spectrum = LM.getAbsorbedPowerMeasurement(x);
    // absorbed power for the first bucket: 380 -397nm
    float ap380_397 = spectrum.data[0];
 
    // accumulate absorbed power into four buckets
    float b0 = 0, b1 = 0, b2 = 0, b3 = 0;
    for(int i:(0:4)) {
        b0 += spectrum.data[ 0+i]; // 0-4
        b1 += spectrum.data[ 5+i]; // 5-9
        b2 += spectrum.data[10+i]; // 10-14
        b3 += spectrum.data[15+i]; // 15-19
    }

After the light model is set up, the next step is to define the spectral light sources. The GPUFlux light model works with all basic light nodes, such as PointLight, SpotLight, or DirectionalLights, but to fully realize the potential of spectral light modelling, it is necessary to define the emitted spectrum of the light source. The emitted spectrum can be defined as power intensities per wavelength, specifying the amplitude for specific wavelengths. Using the following spectrum will result in a dark magenta colour.

WAVELENGTHS = {380, 410, 420, 450, 465, 480, 490, 600, 620, 630, 640, 655, 660, 670, 690, 700, 720};
AMPLITUDES = {0.05, 0.1, 0.4, 0.63, 0.25, 0.15, 0.05, 0.01, 0.1, 0.3, 0.4, 0.85, 0.75, 0.95, 0.6, 0.25, 0.1};

Note: The step size does not have to be equal, and values in between are linearly interpolated. The unit of the amplitudes is either given absolutely in watts or normalized between zero and one. The wavelength array is assumed to be sorted from low to high.

A spectrum, given by an array of wavelengths and corresponding amplitudes, is called a spectral curve, and in computer graphics, it defines a spectral power distribution. In GroIMP, a spectral curve can be defined using the IrregularSpectralCurve class, which takes the wavelength array and the corresponding amplitudes as input. The IrregularSpectralCurve can be used as input to the ChannelSPD class so that it can later be used as input for the light node.

const float[] WAVELENGTHS = {380, 410, 420, 450, 465, 480, 490, 600, 620, 630, 640, 655, 660, 670, 690, 700, 720};
const AMPLITUDES = {0.05, 0.1, 0.4, 0.63, 0.25, 0.15, 0.05, 0.01, 0.1, 0.3, 0.4, 0.85, 0.75, 0.95, 0.6, 0.25, 0.1};
 
const ChannelSPD TEST_SPD = new ChannelSPD(new IrregularSpectralCurve(WAVELENGTHS, AMPLITUDES)); 

Besides user-defined spectral curves, GroIMP provides a set of spectral curves:

• BlackbodySpectralCurve
• ConstantSpectralCurve
• RegularSpectralCurve
• RGBSpectralCurve
• CIENormSpectralCurve

Since these spectral curve classes all implement the same SpectralCurve interface, they can be used in the same way and therefore exchanged.

//user defined spectral curve, applied to an IrregularSpectralCurve
float[] WAVELENGTHS = {380, 485, 490, 610, 615, 720};
float[] AMPLITUDES = {0,0,1,1,0,0};
ChannelSPD GREEN_SPD = new ChannelSPD(new IrregularSpectralCurve(WAVELENGTHS, AMPLITUDES)); 
 
//definition of a green SPD using a RGBSpectralCurve
ChannelSPD GREEN_SPD = new ChannelSPD(new RGBSpectralCurve(0,1,0)); 
 
//a constant spectral curve of the intensity of 0.25 equally over the whole spectrum
ChannelSPD CONST_SPD = new ChannelSPD(new ConstantSpectralCurve(0.25));
 
//a regular spectral curve will apply the given intensities over the specified range ([400,700])
ChannelSPD REG_SPD = new ChannelSPD(new  RegularSpectralCurve(new float[] {0.1, 0.9,0.2,0.1,0.4}, 400, 700));
 
//a CIE Norm D55 spectral curve - sun light
ChannelSPD REG_SPD = new ChannelSPD(new CIENormSpectralCurve(Attributes.CIE_NORM_D55));
 
// a black body spectral curve with a temperature of 5000K
ChannelSPD REG_SPD = new ChannelSPD(new BlackbodySpectralCurve(5000));

To use the spectral curve as input for a light source, a SpectralLight needs to be defined.

const float[] WAVELENGTHS = {380,385,...};
const float[] AMPLITUDES = {0.000967721, 0.000980455, ...};
 
module MyLamp extends LightNode() {
    {
        setLight(
            new SpectralLight(new IrregularSpectralCurve(WAVELENGTHS, AMPLITUDES)).(
                setPower(100), // [W]
                setLight(new PointLight())
            ) // end SpectralLight
        ); // end setLight
    }
}

To complete the definition of a light source, besides the spectral power distribution, the physical light distribution (PLD), which defines the light pattern, needs to be defined. This is especially helpful or necessary for any definition of artificial light sources, such as those found in greenhouses, including HPS lamps or modern LED-based light systems.

The physical light distribution can be defined as a polar distribution diagram (also called polar curve) showing the luminous intensity values with increasing angles from two imaginary axes of the lamp which is placed in the centre. Red: 0–180◦ plane, blue 90–270◦ plane. On the right of the Figure below, a 3D visualisation of the same light source is given. The colour of each point (gradient from black to bright red), as well as the distance to the light source, both indicate the power emitted by the light source in a particular direction per unit solid angle.

Within GroIMP, the PLD can be visualized for any light source, as illustrated below for a SpotLight. To activate the light ray visualization, the setVisualize function just needs to be set to true. Optionally, the number of visualized light rays and their length can be adjusted.

protected void init () [
    Axiom ==> LightNode.(setLight(
        new SpotLight().(
            setInnerAngle(0.02),
            setOuterAngle(0.7),
            setPower(100),
            setVisualize(true), //turn on the light ray visualization
            setNumberofrays(500), //set the number of visualized light rays
            setRaylength(2) //set the length of the visualized light rays
        )));
]

The result of the light ray visualization, i.e., the visualization of the physical light distribution, could look like the image below for different light sources: a) spotlight, with a defined opening angle; b) user-defined distribution; c) point light, equally distributed; d) directional light, equal distribution over an area.

To see a more realistic light pattern, the scene needs to be rendered using one of the light models. Below is a rendered image of the LampDemo.gsz, as it can be found in the GroIMP internal example gallery.

Defining a PLD for a light source can be done in two ways: 1) 'manually' by defining the polar curve as an array of intensities within XL, or 2) by importing a PLD file—as it is provided by most professional light companies for their products.

In any case, instead of one of the predefined light sources, such as PointLight, SpotLight, or DirectionalLight, a so-called PhysicalLight needs to be defined. The PhysicalLight allows us to apply a PLD to it. For the 'manual way,' the PLD is defined as a two-dimensional array (called DISTRIBUTION in the code snippet below) that is then passed as an input parameter to the PhysicalLight class.

// definition of the PLD
const double[][] DISTRIBUTION = {
 {131.25, 131.67, 132.37,...},
 {131.36, 131.81, 132.11,...},
 ...
};
 
const float[] WAVELENGTHS = {380,385,...};
const float[] AMPLITUDES = {0.000967721, 0.000980455, ...};
 
module MyLamp extends LightNode() {
    {
        setLight(
            new SpectralLight(new IrregularSpectralCurve(WAVELENGTHS, AMPLITUDES)).(
                setPower(100), // [W]
                setLight(new PhysicalLight(DISTRIBUTION)) //here the PLD is used
            ) // end SpectralLight
        ); // end setLight
    }
}

After the definition of the global illumination model and the light sources, the last missing part required for proper spectral light modelling is the definition of the local illumination model. In computer graphics, the tools used are called Shaders. A shader defines the local optical properties of an object, namely the values for reflection, absorption, and transmission. The Phong illumination model, or Phong shader for short, allows us to define all required aspects.

In the same way as the spectral curves are defined for the light sources, the spectrum for reflectance and transmission needs to be defined for our spectral shader. 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: Absorption = Total - Reflectance - Transmission.

Note: there is no check of plausibility implemented within the Phong shader. The user needs to make sure that the sum of reflectance and transmission is not higher than the actual incoming radiation. You cannot reflect or transmit more than what was incoming; otherwise, the object would be a light source emitting light.

A Phong shader can be defined as following:

float[] WAVELENGTHS = {380, 485, 490, 610, 615, 720};
float[] AMPLITUDES = {0,0,1,1,0,0};
ChannelSPD GREEN_SPD = new ChannelSPD(new IrregularSpectralCurve(WAVELENGTHS, AMPLITUDES)); 
 
ChannelSPD RED_SPD = new ChannelSPD(new RGBSpectralCurve(0.8,0,0)); 
ChannelSPD CONST_SPD = new ChannelSPD(new ConstantSpectralCurve(0.25)); 
 
Phong myShader = new Phong();
myShader.setDiffuse(GREEN_SPD);
myShader.setTrasnparency(RED_SPD);
 
 
//within a module that extends a Box
module TestBox extends Box(0.001,1,1) {
 
    //define a variable of type Phong and call it myShader
    Phong myShader = new Phong();
 
    //within the static constructor function - automatically called whenever a TestBox is generated 
    // the shader is parametrized and applied to the TestBox
    {
        //define the shader aspects
        myShader.setDiffuse(GREEN_SPD);
        myShader.setTransparency(RED_SPD);
        myShader.setSpecularCONST_SPD);
 
        //set the shader to the TestBox
        setShader(myShader);
    }
}
 
//as a module that is interpreted as Box
module TestBox ==> {
    Phong myShader = new Phong();
} Box(0.001,1,1).(setShader(myShader));

To monitor light distributions with a scene without interfering, GroIMP provides the SensorNode class, a sphere that can be placed arbitrarily within the scene. To obtain the sensed spectrum, the getSensedIrradianceMeasurement function needs to be called.

Note: the size of the sensor node directly correlates with the probability of got hit by a light ray. For a very small sphere the probability to got hit by a light ray is relatively low, so the number of light rays simulated by the light model needs to be much larger to get repayable results. Therefore, better not to use very small sensor nodes.

Note: the colour of the sensor node determines which wavelengths should be observed. The default value is white, what stands for monitor all colours. If, for instance, the sensor colour is set to red, only red spectra will be sensed.

Note: the output of a sensor node is normalized to absorbed radiance per square meter, independent of the actual size of the sensor.

Note: Sensor nodes can be enabled and disabled for the light model using the LM.setEnableSensors(true/false) function. By default they are disabled, since GroIMP version 2.1.4, before they were enabled by default. Having them disabled speeds up the light computation time for scenarios where not sensor nodes are involved.

// create a 5cm, white sensor node
Axiom ==> SensorNode().(setRadius(0.05), setColor(1, 1, 1));
 
//check what the sensor node has sensed
x:SensorNode ::> {
    Measurement spectrum = lm.getSensedIrradianceMeasurement(x);
    float absorbedPower = spectrum.integrate();
    ...
}

Beside defining the SPD and PLD as arrays within XL, GroIMP supports the import of common file formates for both.

Both can be imported in the same way by open the Panels Tab and go to Explorers first. For PLD, the 'Create new distribution object' needs to be called and for SPD 'Create new spectra object' is used. In the new panel, Object → New → file/spectrallightmapnode needs to be selected to get a file dialogue where the wanted file can be selected. After the file is imported, it is recommended to give the reference a self-explanatory name for easy use later within the code.

To access the imported light spectra and physical light distributions within XL, one needs to define a reference to the files in the following way:

//Definition of references
const LightDistributionRef DISTRIBUTION = light(”distri1”); // for PLDs references
const SpectrumRef SPECTRUM = spectrum(”equal”); // for SPDs references
 
set them via the constructor
module MyLamp extends LightNode {
    {
        setLight(new SpectralLight(new PhysicalLight(DISTRIBUTION),SPECTRUM, 5));
    }
}

The code below is an extended minimal working example to illustrate most of the above explained aspects of spectral light modelling.

It defines a spectral light source, a test object with a spectral shader and runs the GPUFlux light model to calculate the light absorption of the test object. Additionally, a chart is introduced, visualizing the light spectrum of the light source versus the absorbed spectrum of the test shader.

Special thanks to Dietger van Antwerpen, who implemented the GPUFlux light model for GroIMP!

• Henke M and Buck-Sorlin GH (2018) Using a full spectral raytracer for the modelling of light microclimate in a functional-structural plant model; Computing and Informatics, 36(6), 1492-1522, doi: 10.4149/cai_2017_6_1492, https://www.cai.sk/ojs/index.php/cai/article/view/2017_6_1492
• van Antwerpen, D.G. (2011) High Performance Spectral Light Transport Model for Agricultural Applications, Poster HPG
• van Antwerpen, D.G. (2011) Unbiased physically based rendering on the GPU, Master thesis, Delft University of Technology