Differences

This shows you the differences between two versions of the page.

--- tutorials:basic-spectral-light-modeling [2024/12/03 07:28] – extended MH
+++ tutorials:basic-spectral-light-modeling [2025/01/08 21:30] (current) – MH
@@ Line 1: / Line 1: @@
 ====== Spectral Light Modelling ======
-===== General Introduction =====
-Light modelling generally involves three aspects:
-  * Global illumination model
-  * Light sources
-  * Local illumination model
-{{ :tutorials:light1.png?direct&400 |}}
-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.
-{{ :tutorials:light2.png?direct&400 |}}
-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.
-{{ :tutorials:light3.png?direct&400 |}}
-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.
-{{ :tutorials:light4.png?direct&200 |}}
-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.
-{{ :tutorials:light5.png?direct&200 |}}
-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.
-{{ :tutorials:light6.png?direct&400 |}}
-===== 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.
@@ Line 72: / Line 26: @@
 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.
+Note: The examples require GroIPM version >=2.0 to run. With GroIMP version 2.0 some changes on the internal package structure are made. formally classes found in  de.grogra.imp3d have been moved to de.grogra.gpuflux.imp3d to match the package name (Java 11 forbid package name split). So, if you are using objects, lights or shaders from gpuflux, they should be imported as de.grogra.gpuflux.imp3d.xxx.
+<code java>
+import de.grogra.imp3d.spectral.IrregularSpectralCurve; // old - before GroIMP 2.0
+import de.grogra.gpuflux.imp3d.spectral.IrregularSpectralCurve; // new - with GroIMP 2.0
+// Light nodes need to be imported like this
+import de.grogra.gpuflux.imp3d.objects.PhysicalLight;
+</code>
 <code java>
-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;
 ...
@@ Line 85: / Line 46: @@
 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
@@ Line 106: / Line 66: @@
 // disables the simulation of sensor
-LM.setEnableSensors(false); // default: true
+LM.setEnableSensors(true); // default: false
 // sets the random seed for the random number generator; us this to obtain reproducible results
 LM.setRandomseed(123456);
-// disables dispersion
+// enable dispersion
-LM.setDispersion(false); // default: true
+LM.setDispersion(ture); // default: false
 </code>
@@ Line 316: / Line 276: @@
 Phong myShader = new Phong();
 myShader.setDiffuse(GREEN_SPD);
-myShader.setTrasnparency(RED_SPD);
+myShader.setTransparency(RED_SPD);
@@ Line 331: / Line 291: @@
         myShader.setDiffuse(GREEN_SPD);
         myShader.setTransparency(RED_SPD);
-        myShader.setSpecularCONST_SPD);
+        myShader.setSpecular(CONST_SPD);
         //set the shader to the TestBox
@@ Line 343: / Line 303: @@
 } Box(0.001,1,1).(setShader(myShader));
 </code>
+Within the //CIENormSpectralCurve// class, a small database of several predefined standard spectral curves is given:
+  * on 1nm resolution [300, 780]
+    * A, D65
+  * on 5nm resolution [300, 780]
+    * A, C, D50, D55, D65, D75
+  * on 5nm resolution [380, 780]
+    * FL1-12, FL3_1-15, HP1-5
+For instance, to use the predefined CIE NORM D65 for typical sun light within a user defined light module, one could use the following code.
+<code java>
+import de.grogra.imp3d.objects.Attributes;
+import de.grogra.gpuflux.imp3d.spectral.CIENormSpectralCurve;
+//define a light module
+module MyLamp extends LightNode {
+  {
+    setLight(
+      new SpectralLight(
+        new CIENormSpectralCurve(Attributes.CIE_NORM_D65)
+      ).(
+	setPower(100), //[W]
+	setLight(
+	  new SpotLight(DISTRIBUTION).(
+	    setVisualize(true), //activate light ray visualization
+            setNumberofrays(250),
+            setRaylength(1)// [m]
+          )
+        )
+      ) //end SpectralLight
+    ); //end setLight
+  }
+}
+</code>
+Note: Do NOT mix common RGB shader like the //RGBAShader// with spectral shader! This applies for having RGB and spectral shader within the same model but in different objects but also for one (Phong) shader thas combines RGB and spectral shader. The ranges of common RGB shader will most probably not match the ranges of the other shader and simulated light spectrum what will inevitable lead to fals results.
@@ Line 349: / Line 349: @@
 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 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 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: 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.
@@ Line 396: / Line 396: @@
 ==== Example ====
-The code below is an extended minimal working example to illustrate most of the above explained aspects of spectral light modelling.
+In the following four minimal working examples are given to illustrate: the light model, the definition of light sources, adding a object and define a spectral shader, and on how to visualize the results. The four examples are building on each other, meaning with each example new parts will extend the previous code.
-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.
+Note: The examples require GroIMP version >=2.0 to run. With GroIMP version 2.0 some changes on the internal package structure are made. formally classes found in  //de.grogra.imp3d// have been moved to //de.grogra.gpuflux.imp3d// to match the package name (Java 11 forbid package name split). So, if you are using objects, lights or shaders from //gpuflux//, they should be imported as //de.grogra.gpuflux.imp3d.xxx//.
 <code java>
+import de.grogra.imp3d.spectral.IrregularSpectralCurve; // old - before GroIMP 2.0
+import de.grogra.gpuflux.imp3d.spectral.IrregularSpectralCurve; // new - with GroIMP 2.0
+// Light nodes need to be imported like this
+import de.grogra.gpuflux.imp3d.objects.PhysicalLight;
+</code>
+=== Example 1 - Light Model ===
+This example just defines the GPUFlux light model and parameterizes it to simulate a spectrum from 300 to 800nm and measure the results in 30 buckets.
+<code java>
+import de.grogra.gpuflux.tracer.FluxLightModelTracer.MeasureMode;
+//constants for the light model: number of rays and maximal recursion depth
+const int RAYS = 1000000;
+const int DEPTH = 10;
+//initialize the scene
+protected void init () {
+	//initialize the spectral light model
+	println("Run GPU light model", 0x000000);
+	FluxLightModel GPU_LM = new FluxLightModel(RAYS, DEPTH);
+	GPU_LM.setSeed(12345); // to produce reproducible results
+	GPU_LM.setMeasureMode(MeasureMode.FULL_SPECTRUM);
+	GPU_LM.setSpectralDomain(300,800);// spectral range monitored
+	GPU_LM.setSpectralBuckets(31);// range divided into 30 buckets
+	GPU_LM.compute();// run the light model - may take a few seconds
+}
+</code>
+The model will run and directly when saved, creates an instance of the light model, set wanted parameters and run it. there will be no output (except the one form the light model itself, stating that it was executed and giving some statistics on the scene).
+If you already get errors here, your system most probably does not support spectral light modelling.
+=== Example 2 - Light Sources ===
+This example defines a spectral light source with a user define physical light distribution (PLD) and a predefined CIE NORM D55 as spectral power distribution (SPD) (used to define typical sun light) and add the light source to the scene.
+<code java>
+import de.grogra.gpuflux.imp3d.spectral.CIENormSpectralCurve;
+import de.grogra.gpuflux.imp3d.spectral.IrregularSpectralCurve;
+import de.grogra.gpuflux.imp3d.objects.SpectralLight;
+import de.grogra.gpuflux.imp3d.objects.PhysicalLight;
+import de.grogra.gpuflux.tracer.FluxLightModelTracer.MeasureMode;
+import de.grogra.gpuflux.scene.experiment.Measurement;
+////////////////////////////////////////////////////////////////////////////////
+//definition of a physical light distribution
+const double[][] DISTRIBUTION = {
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+};
+//use the predefined CIE NORM D65 for typical sun light
+static const float[] WAVELENGTHS_S = CIENormSpectralCurve.NM_300_780_5;
+static const float[] AMPLITUDES_S = CIENormSpectralCurve.D65;
+//define a light node
+module MyLamp extends LightNode {
+  {
+    setLight(
+    	new SpectralLight(
+    		new IrregularSpectralCurve(WAVELENGTHS_S, AMPLITUDES_S)
+    	).(
+			setPower(7.8), //adapt the power to match the two curves
+			setLight(
+				new PhysicalLight(DISTRIBUTION).(
+					setVisualize(true), //activate light ray visualization
+					setNumberofrays(500),
+					setRaylength(3.5)
+				)
+			)
+		) //end SpectralLight
+	); //end setLight
+  }
+}
+//constants for the light model: number of rays and maximal recursion depth
+const int RAYS = 1000000;
+const int DEPTH = 10;
+//initialize the scene
+protected void init () {
+	//create the actual 3D scene
+	[
+		Axiom ==> MyLamp;
+	]
+	//make sure the changes on the graph are applied...
+	{derive();}
+	//so that we directly can continue and work on the graph
+	//initialize the spectral light model
+	println("Run GPU light model", 0x000000);
+	FluxLightModel GPU_LM = new FluxLightModel(RAYS, DEPTH);
+	GPU_LM.setSeed(12345); // to produce reproduceable results
+	GPU_LM.setMeasureMode(MeasureMode.FULL_SPECTRUM);
+	GPU_LM.setSpectralDomain(300,800);// spectral range monitored
+	GPU_LM.setSpectralBuckets(31);// range divided into 30 buckets
+	GPU_LM.compute();// run the light model - may take a few seconds
+}
+</code>
+Since the visualization of the light rays is turned on for the light source, we can see the light source in the 3D view window.
+{{ :tutorials:light_example1.png?direct&400 |}}
+=== Example 3 - Scene object and shader ===
+Here now we define a test object, s simple flat box of one square meter in dimension and apply a green spectral shader to it. The 3D view window should now show something similar to this:
+{{ :tutorials:light_example2.png?direct&400 |}}
+<code java>
+import de.grogra.gpuflux.imp3d.spectral.CIENormSpectralCurve;
+import de.grogra.gpuflux.imp3d.shading.ChannelSPD;
+import de.grogra.gpuflux.imp3d.spectral.IrregularSpectralCurve;
+import de.grogra.gpuflux.imp3d.objects.SpectralLight;
+import de.grogra.gpuflux.imp3d.objects.PhysicalLight;
+import de.grogra.gpuflux.tracer.FluxLightModelTracer.MeasureMode;
+import de.grogra.gpuflux.scene.experiment.Measurement;
+////////////////////////////////////////////////////////////////////////////////
+//definition of a physical light distribution
+const double[][] DISTRIBUTION = {
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+};
+//use the predefined CIE NORM D65 for typical sun light
+static const float[] WAVELENGTHS_S = CIENormSpectralCurve.NM_300_780_5;
+static const float[] AMPLITUDES_S = CIENormSpectralCurve.D65;
+//define a light node
+module MyLamp extends LightNode {
+  {
+    setLight(
+    	new SpectralLight(
+    		new IrregularSpectralCurve(WAVELENGTHS_S, AMPLITUDES_S)
+    	).(
+			setPower(7.8), //adapt the power to match the two curves
+			setLight(
+				new PhysicalLight(DISTRIBUTION).(
+					setVisualize(true), //activate light ray visualization
+					setNumberofrays(500),
+					setRaylength(3.5)
+				)
+			)
+		) //end SpectralLight
+	); //end setLight
+  }
+}
+////////////////////////////////////////////////////////////////////////////////
+//define a green shader as user-defined irregular spectral curve
+public const float[] WAVELENGTHS = {300, 525, 530, 575, 580, 800};
+public const float[] AMPLITUDES = {0,0,1,1,0,0};
+const ChannelSPD GREEN_SPD = new ChannelSPD(new IrregularSpectralCurve(WAVELENGTHS, AMPLITUDES));
+//apply the shader to an object: a box of one square meter
+module TestShader ==> {
+	Phong myShader = new Phong();
+	//myShader.setDiffuse(new RGBColor (0,1,0));
+	myShader.setDiffuse(GREEN_SPD);
+} Box(0.001,1,1).(setShader(myShader));
+////////////////////////////////////////////////////////////////////////////////
+//constants for the light model: number of rays and maximal recursion depth
+const int RAYS = 1000000;
+const int DEPTH = 10;
+//initialize the scene
+protected void init () {
+	clearConsole();
+	//create the actual 3D scene
+	[
+		Axiom ==> TestShader M(2) RL(180) MyLamp;
+	]
+	//make sure the changes on the graph are applied...
+	{derive();}
+	//so that we directly can continue and work on the graph
+	//initialize the spectral light model
+	println("Run GPU light model", 0x000000);
+	FluxLightModel GPU_LM = new FluxLightModel(RAYS, DEPTH);
+	GPU_LM.setSeed(12345); // to produce reproduceable results
+	GPU_LM.setMeasureMode(MeasureMode.FULL_SPECTRUM);
+	GPU_LM.setSpectralDomain(300,800);// spectral range monitored
+	GPU_LM.setSpectralBuckets(31);// range divided into 30 buckets
+	GPU_LM.compute();// run the light model - may take a few seconds
+	//check the scene objects for their light absorption
+	Measurement ms;
+	[
+		x:TestShader ::> { ms = GPU_LM.getAbsorbedPowerMeasurement(x); }
+	]
+	println(""+ms.integrate()+" = "+ms, 0xff0000);
+}
+</code>
+To obtain the measurement results, one needs to first run the light model and second check each (wanted) scene object for its absorption values. A simple graph query can eb used to implement the second part, where here is searched for all TestShader instances within the graph and the light absorption is obtained. Afterwards the results a printed to the GroIMP console window. The output of the code is the integrated absorbed power and the array of the absorption values for each bucket.
+{{ :tutorials:light_example3.png?direct&400 |}}
+=== Example 4 - Output visualization ===
+In the final version, we are now going to add a charts to visualize the emitted spectrum and to plot it against the absorbed spectrum of the test object.
+{{ :tutorials:light_example4.png?direct&400 |}}
+<code java>
+import de.grogra.gpuflux.imp3d.spectral.CIENormSpectralCurve;
+import de.grogra.gpuflux.imp3d.shading.ChannelSPD;
+import de.grogra.gpuflux.imp3d.spectral.IrregularSpectralCurve;
+import de.grogra.gpuflux.imp3d.objects.SpectralLight;
+import de.grogra.gpuflux.imp3d.objects.PhysicalLight;
+import de.grogra.gpuflux.tracer.FluxLightModelTracer.MeasureMode;
+import de.grogra.gpuflux.scene.experiment.Measurement;
+////////////////////////////////////////////////////////////////////////////////
+//definition of a physical light distribution
+const double[][] DISTRIBUTION = {
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	{1, 1, 1,1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+};
+//use the predefined CIE NORM D65 for typical sun light
+static const float[] WAVELENGTHS_S = CIENormSpectralCurve.NM_300_780_5;
+static const float[] AMPLITUDES_S = CIENormSpectralCurve.D65;
+//define a light node
+module MyLamp extends LightNode {
+  {
+    setLight(
+    	new SpectralLight(
+    		new IrregularSpectralCurve(WAVELENGTHS_S, AMPLITUDES_S)
+    	).(
+			setPower(7.8), //adapt the power to match the two curves
+			setLight(
+				new PhysicalLight(DISTRIBUTION).(
+					setVisualize(true), //activate light ray visualization
+					setNumberofrays(500),
+					setRaylength(3.5)
+				)
+			)
+		) //end SpectralLight
+	); //end setLight
+  }
+}
+////////////////////////////////////////////////////////////////////////////////
+//define a green shader as user-defined irregular spectral curve
+public const float[] WAVELENGTHS = {300, 525, 530, 575, 580, 700};
+public const float[] AMPLITUDES = {0,0,1,1,0,0};
+const ChannelSPD GREEN_SPD = new ChannelSPD(new IrregularSpectralCurve(WAVELENGTHS, AMPLITUDES));
+//apply the shader to an object: a box of one square meter
+module TestShader ==> {
+	Phong myShader = new Phong();
+	//myShader.setDiffuse(new RGBColor (0,1,0));
+	myShader.setDiffuse(GREEN_SPD);
+} Box(0.001,1,1).(setShader(myShader));
+////////////////////////////////////////////////////////////////////////////////
+//define the data sheet
+const DatasetRef absorbedChart = new DatasetRef("Power [W]");
+//constants for the light model: number of rays and maximal recursion depth
+const int RAYS = 1000000;
+const int DEPTH = 10;
+//initialize the scene
+protected void init () {
+	clearConsole();
+	//initialize the chart
+	absorbedChart.clear().setColumnKey(0,"source emitted").setColumnKey(1,"ground absorbed");
+	chart(absorbedChart, XY_PLOT);
+	//plot the emitted spectral curve
+	float INTEGRAL = 0;
+	for(int i:(0:AMPLITUDES_S.length-1)) INTEGRAL+=AMPLITUDES_S[i];
+	for(int i:(0:WAVELENGTHS_S.length-1)) {
+		absorbedChart.addRow().(set(0, WAVELENGTHS_S[i], AMPLITUDES_S[i]/INTEGRAL));
+	}
+	//create the actual 3D scene
+	[
+		Axiom ==> TestShader M(2) RL(180) MyLamp;
+	]
+	//make sure the changes on the graph are applied...
+	{derive();}
+	//so that we directly can continue and work on the graph
+	//initialize the spectral light model
+	println("Run GPU light model", 0x000000);
+	FluxLightModel GPU_LM = new FluxLightModel(RAYS, DEPTH);
+	GPU_LM.setSeed(12345); // to produce reproduceable results
+	GPU_LM.setMeasureMode(MeasureMode.FULL_SPECTRUM);
+	GPU_LM.setSpectralDomain(300,800);// spectral range monitored
+	GPU_LM.setSpectralBuckets(31);// range divided into 30 buckets
+	GPU_LM.compute();// run the light model - may take a few seconds
+	//check the scene objects for their light absorption
+	Measurement ms;
+	[
+		x:TestShader ::> { ms = GPU_LM.getAbsorbedPowerMeasurement(x); }
+	]
+	print("absorbed = "+ms);println(""+ms.integrate()+" = "+ms, 0xff0000);
+	//plot the absorption spectrum
+	for(int i:(0:ms.data.length-1)) {
+		absorbedChart.addRow().(set(1, 300+i*16.129, ms.data[i])); //500/31=16.129
+	}
+}
 </code>