Light modelling, in general, involves three aspects:

• Global illumination model
• Light sources
• Local illumination model

where as the Global illumination model is doing the actual light computation, the Light sources are the light emitting elements, and Local illumination model defines the optical properties of the scene objects.

For each aspect, computer graphics knows 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 is discussed.

Regarding light sources, GroIMP provides the whole set of possible implementations. They all implementing the Light and LightBase interface what makes them handled equally and so easy to exchange.

For the Local illumination model, that defines the optical properties of the scene objects, i.e. values for absorption, transmission and reflection, so-called shader 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) is a combination of ambient, diffuse, and specular light reflection.

These three core aspects of light simulation, the global and local illumination model, and light sources, are the base for any light simulation. When it now comes to spectral light simulations, specialized implementations of the above mentioned aspects are required, able to simulate not only one or three light channels - as typical for common light models - but moreover able to simulate the whole light spectrum for different wavelengths.

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

The main factor to influence the light quality is the light spectral composition - commonly called colour. So, the compositions of different intensities of different wavelengths, that together form the final light spectrum or colour. Below are the light spectra of typical sun light, of a common HPS-lamps (high-pressure sodium lamp), as they are 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 to 720 nm (default values).

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

The spectral range [minLambda, maxLambda] can be divided into an user-defined number of equal sized so-called buckets - sub-channels. They can be one, taking the whole range as one channel - what, in my opinion would not make much sense - or can be as big as the number of integer wavelengths of the range, leading to 1nm buckets if wanted. Common numbers of buckets are something between 5 and 30, but totally depends on the application. Below an example of a 380-720nm spectrum divided into 20 buckets, each of them with a 17nm range.

Setting up the GPUFlux light model within GroIMP, or better XL, follows the typical Java conventions of importing the required classes, and initialization and parametrization of 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, that simulates only three buckets approximating the three colour channels
• full 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 following:

LM.compute();

To obtain the total abound 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, e.g., 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 thing to do is the definition of spectral light sources. The GPUFlux light model works with all basic light nodes, e.g., PointLight, SpotLight, or DirectionalLights, but to get the full potential of spectral light modelling, we need to define the emitted spectrum of the light source. The emitted spectrum can be defined as power intensities per wavelength, defining the amplidue for specific wavelengths. Taking the following spectrum

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};

will lead to some dark magenta.

Note: The step size does not to be equal and values in-between are linear interpolated. The unit of the amplitudes are ether given absolute in Watt or are normalized between zero and one. The wavelength array is assumed to be sorted low to high.

A spectra, given by an array of wavelengths and corresponding amplitudes is called spectral curve and in computer graphics it defines a spectral power distribution. In GroIMP a spectral curve and 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 be used later 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)); 

Beside user defined spectral curves, GroIMP provides a set of spectral curves:

• BlackbodySpectralCurve
• ConstantSpectralCurve
• RegularSpectralCurve
• RGBSpectralCurve
• CIENormSpectralCurve

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

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 GREEN_SPD = new ChannelSPD(new RGBSpectralCurve(1,1,0)); 
ChannelSPD CONST_SPD = new ChannelSPD(new ConstantSpectralCurve(0.25));
ChannelSPD REG_SPD = new ChannelSPD(new  RegularSpectralCurve(new float[] {0.1, 0.9,0.2,0.1,0.4}, 400, 700));
ChannelSPD REG_SPD = new ChannelSPD(new CIENormSpectralCurve(Attributes.CIE_NORM_D55));
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, beside the spectral power distribution, the physical light distribution (PLD), what defines the light pattern, needs to be defined. This is especially helpful/necessary for any definition of artificial light sources as they can be found in greenhouses, such as 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 a 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. Optional, 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 in the image below for different light sources: a) spot light, with a defined opening angle; b) user defined distribution; c) point light, equally distributed; d) directional light, equal distribution over an area.

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

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

In any case, instead of one of the predefined light sources, e.g., 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 'manual way' the PLD is defined a two-dimensional array (called DISTRIBUTION in the code snippet below) that is the passed as 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
    }
}

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