add color framework to prepare for spectral rendering

src/main/java/eu/jonahbauer/raytracing/Examples.java

@@ -1,6 +1,5 @@
 package eu.jonahbauer.raytracing;
 
-import eu.jonahbauer.raytracing.math.AABB;
 import eu.jonahbauer.raytracing.math.Vec3;
 import eu.jonahbauer.raytracing.render.texture.CheckerTexture;
 import eu.jonahbauer.raytracing.render.texture.Color;
@@ -293,7 +292,7 @@ public class Examples {
 
         return new Example(
                 new Scene(getSkyBox(), List.of(
-                        new Sphere(Vec3.ZERO, 2, new LambertianMaterial(new ImageTexture("/earthmap.jpg")))
+                        new Sphere(Vec3.ZERO, 2, new LambertianMaterial(new ImageTexture("/eu/jonahbauer/raytracing/textures/earthmap.jpg")))
                 )),
                 SimpleCamera.builder()
                         .withImage(height * 16 / 9, height)
@@ -369,7 +368,7 @@ public class Examples {
         ));
 
         // textures spheres
-        objects.add(new Sphere(new Vec3(400, 200, 400), 100, new LambertianMaterial(new ImageTexture("/earthmap.jpg"))));
+        objects.add(new Sphere(new Vec3(400, 200, 400), 100, new LambertianMaterial(new ImageTexture("/eu/jonahbauer/raytracing/textures/earthmap.jpg"))));
         objects.add(new Sphere(new Vec3(220, 280, 300), 80, new LambertianMaterial(new PerlinTexture(0.2))));
 
         // box from spheres

src/main/java/eu/jonahbauer/raytracing/math/Matrix3.java

@@ -0,0 +1,255 @@
+package eu.jonahbauer.raytracing.math;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public record Matrix3(
+        double a11, double a12, double a13,
+        double a21, double a22, double a23,
+        double a31, double a32, double a33
+) {
+    public static @NotNull Matrix3 fromRows(@NotNull Vec3 @NotNull[] rows) {
+        if (rows.length != 3) throw new IllegalArgumentException();
+        return fromRows(rows[0], rows[1], rows[2]);
+    }
+
+    public static @NotNull Matrix3 fromRows(@NotNull Vec3 row0, @NotNull Vec3 row1, @NotNull Vec3 row2) {
+        return new Matrix3(
+                row0.x(), row0.y(), row0.z(),
+                row1.x(), row1.y(), row1.z(),
+                row2.x(), row2.y(), row2.z()
+        );
+    }
+
+    public static @NotNull Matrix3 fromColumns(@NotNull Vec3 @NotNull[] cols) {
+        if (cols.length != 3) throw new IllegalArgumentException();
+        return fromColumns(cols[0], cols[1], cols[2]);
+    }
+
+    public static @NotNull Matrix3 fromColumns(@NotNull Vec3 col0, @NotNull Vec3 col1, @NotNull Vec3 col2) {
+        return new Matrix3(
+                col0.x(), col1.x(), col2.x(),
+                col0.y(), col1.y(), col2.y(),
+                col0.z(), col1.z(), col2.z()
+        );
+    }
+
+    public static @NotNull Matrix3 fromArray(double @NotNull[] @NotNull[] array) {
+        return new Matrix3(
+                array[0][0], array[0][1], array[0][2],
+                array[1][0], array[1][1], array[1][2],
+                array[2][0], array[2][1], array[2][2]
+        );
+    }
+
+    public Matrix3() {
+        this(1, 1, 1);
+    }
+
+    public Matrix3(double a11, double a22, double a33) {
+        this(a11, 0, 0, 0, a22, 0, 0, 0, a33);
+    }
+
+    public @NotNull Matrix3 times(@NotNull Matrix3 other) {
+        return new Matrix3(
+                a11 * other.a11 + a12 * other.a21 + a13 * other.a31,
+                a11 * other.a12 + a12 * other.a22 + a13 * other.a32,
+                a11 * other.a13 + a12 * other.a23 + a13 * other.a33,
+                a21 * other.a11 + a22 * other.a21 + a23 * other.a31,
+                a21 * other.a12 + a22 * other.a22 + a23 * other.a32,
+                a21 * other.a13 + a22 * other.a23 + a23 * other.a33,
+                a31 * other.a11 + a32 * other.a21 + a33 * other.a31,
+                a31 * other.a12 + a32 * other.a22 + a33 * other.a32,
+                a31 * other.a13 + a32 * other.a23 + a33 * other.a33
+        );
+    }
+
+    public @NotNull Matrix3 times(double other) {
+        return new Matrix3(
+                a11 * other, a12 * other, a13 * other,
+                a21 * other, a22 * other, a23 * other,
+                a31 * other, a32 * other, a33 * other
+        );
+    }
+
+    public @NotNull Vec3 times(@NotNull Vec3 other) {
+        return new Vec3(
+                a11 * other.x() + a12 * other.y() + a13 * other.z(),
+                a21 * other.x() + a22 * other.y() + a23 * other.z(),
+                a31 * other.x() + a32 * other.y() + a33 * other.z()
+        );
+    }
+
+    public @NotNull Matrix3 plus(@NotNull Matrix3 other) {
+        return new Matrix3(
+                a11 + other.a11, a12 + other.a12, a13 + other.a13,
+                a21 + other.a21, a22 + other.a22, a23 + other.a23,
+                a31 + other.a31, a32 + other.a32, a33 + other.a33
+        );
+    }
+
+    public double det() {
+        return a11 * a22 * a33 + a12 * a23 * a31 + a13 * a21 * a32
+                - a13 * a22 * a31 - a23 * a32 * a11 - a33 * a12 * a21;
+    }
+
+    public @NotNull Matrix3 invert() {
+        var det = det();
+        if (det == 0) throw new IllegalStateException();
+        var t = 1 / det;
+        return new Matrix3(
+                t * (Math.fma( a22, a33, -a23 * a32)),
+                t * (Math.fma(-a12, a33,  a13 * a32)),
+                t * (Math.fma( a12, a23, -a13 * a22)),
+                t * (Math.fma(-a21, a33,  a23 * a31)),
+                t * (Math.fma( a11, a33, -a13 * a31)),
+                t * (Math.fma(-a11, a23,  a13 * a21)),
+                t * (Math.fma( a21, a32, -a22 * a31)),
+                t * (Math.fma(-a11, a32,  a12 * a31)),
+                t * (Math.fma( a11, a22, -a12 * a21))
+        );
+    }
+
+    public @NotNull Vec3 column(int i) {
+        return switch (i) {
+            case 0 -> new Vec3(a11, a21, a31);
+            case 1 -> new Vec3(a12, a22, a32);
+            case 2 -> new Vec3(a13, a23, a33);
+            default -> throw new IndexOutOfBoundsException(i);
+        };
+    }
+
+    public @NotNull Vec3 @NotNull[] columns() {
+        return new Vec3[] {
+                new Vec3(a11, a21, a31),
+                new Vec3(a12, a22, a32),
+                new Vec3(a13, a23, a33)
+        };
+    }
+
+    public @NotNull Vec3 row(int i) {
+        return switch (i) {
+            case 0 -> new Vec3(a11, a12, a13);
+            case 1 -> new Vec3(a21, a22, a23);
+            case 2 -> new Vec3(a31, a32, a33);
+            default -> throw new IndexOutOfBoundsException(i);
+        };
+    }
+
+    public @NotNull Vec3 @NotNull[] rows() {
+        return new Vec3[] {
+                new Vec3(a11, a12, a13),
+                new Vec3(a21, a22, a23),
+                new Vec3(a31, a32, a33)
+        };
+    }
+
+    public double @NotNull[] @NotNull[] toArray() {
+        return new double[][] {
+                {a11, a12, a13},
+                {a21, a22, a23},
+                {a31, a32, a33}
+        };
+    }
+
+    public double get(int i, int j) {
+        Objects.checkIndex(i, 3);
+        Objects.checkIndex(j, 3);
+        var idx = 3 * i + j;
+        return switch (idx) {
+            case 0 -> a11;
+            case 1 -> a12;
+            case 2 -> a13;
+            case 3 -> a21;
+            case 4 -> a22;
+            case 5 -> a23;
+            case 6 -> a31;
+            case 7 -> a32;
+            case 8 -> a33;
+            default -> throw new AssertionError();
+        };
+    }
+
+    /**
+     * Performs lower-upper decomposition with partial pivoting (LUP decomposition) on {@code this} matrix.
+     * @param tolerance a small tolerance number to detect failure when the matrix is near degenerate
+     * @see <a href="https://en.wikipedia.org/w/index.php?title=LU_decomposition&oldid=1213102558#C_code_example">LU decomposition — Wikipedia, The Free Encyclopedia</a>
+     */
+    public @NotNull LUPDecomposition decompose(double tolerance) {
+        // unit permutation matrix
+        var perm = new int[] {0, 1, 2, 3};
+        var A = toArray();
+        var N = 3;
+
+        for (int i = 0; i < N; i++) {
+            double maxA = 0.0;
+            int imax = i;
+
+            for (int k = i; k < N; k++) {
+                double absA = Math.abs(A[k][i]);
+                if (absA > maxA) {
+                    maxA = absA;
+                    imax = k;
+                }
+            }
+
+            if (maxA < tolerance) throw new IllegalArgumentException("matrix is degenerate");
+
+            if (imax != i) {
+                // pivoting P
+                int j = perm[i];
+                perm[i] = perm[imax];
+                perm[imax] = j;
+
+                // pivoting rows of A
+                var ptr = A[i];
+                A[i] = A[imax];
+                A[imax] = ptr;
+
+                // counting pivots starting from N (for determinant)
+                perm[3]++;
+            }
+
+            for (int j = i + 1; j < N; j++) {
+                A[j][i] /= A[i][i];
+
+                for (int k = i + 1; k < N; k++) {
+                    A[j][k] -= A[j][i] * A[i][k];
+                }
+            }
+        }
+
+        return new LUPDecomposition(fromArray(A), perm);
+    }
+
+    public record LUPDecomposition(@NotNull Matrix3 matrix, int @NotNull[] permutation) {
+
+        /**
+         * Solves the equation {@code Ax = b} where {@code A} is the matrix that {@code this} decomposition was derived
+         * from.
+         * @param b the right hand side vector
+         * @return the solution vector
+         */
+        public @NotNull Vec3 solve(@NotNull Vec3 b) {
+            var N = 3;
+            var x = new double[N];
+            for (int i = 0; i < N; i++) {
+                x[i] = b.get(permutation[i]);
+
+                for (int k = 0; k < i; k++) {
+                    x[i] -= matrix.get(i, k) * x[k];
+                }
+            }
+
+            for (int i = N - 1; i >= 0; i--) {
+                for (int k = i + 1; k < N; k++) {
+                    x[i] -= matrix.get(i, k) * x[k];
+                }
+
+                x[i] /= matrix.get(i, i);
+            }
+            return new Vec3(x[0], x[1], x[2]);
+        }
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/SampledSpectrum.java

@@ -0,0 +1,71 @@
+package eu.jonahbauer.raytracing.render.spectral;
+
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorXYZ;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.texture.Color;
+import org.jetbrains.annotations.NotNull;
+
+public final class SampledSpectrum {
+    private final double @NotNull[] values;
+
+    public SampledSpectrum(@NotNull SampledWavelengths lambdas, @NotNull Spectrum spectrum) {
+        var values = new double[lambdas.size()];
+        for (int i = 0; i < values.length; i++) {
+            values[i] = spectrum.get(lambdas.get(i));
+        }
+        this.values = values;
+    }
+
+    private SampledSpectrum(double @NotNull[] values) {
+        this.values = values;
+    }
+
+    public static @NotNull SampledSpectrum multiply(@NotNull SampledSpectrum a, @NotNull SampledSpectrum b) {
+        var out = new double[a.values.length];
+        for (int i = 0; i < a.values.length; i++) {
+            out[i] = a.values[i] * b.values[i];
+        }
+        return new SampledSpectrum(out);
+    }
+
+    public static @NotNull SampledSpectrum multiply(@NotNull SampledSpectrum a, double b) {
+        var out = new double[a.values.length];
+        for (int i = 0; i < a.values.length; i++) {
+            out[i] = a.values[i] * b;
+        }
+        return new SampledSpectrum(out);
+    }
+
+    public static @NotNull SampledSpectrum add(@NotNull SampledSpectrum a, @NotNull SampledSpectrum b) {
+        var out = new double[a.values.length];
+        for (int i = 0; i < a.values.length; i++) {
+            out[i] = a.values[i] + b.values[i];
+        }
+        return new SampledSpectrum(out);
+    }
+
+    public double get(int index) {
+        return values[index];
+    }
+
+    public int size() {
+        return values.length;
+    }
+
+    public double average() {
+        double avg = 0;
+        for (int i = 0; i < values.length; i++) {
+            avg = Math.fma(1d / (i + 1), values[i] - avg, avg);
+        }
+        return avg;
+    }
+
+    public @NotNull ColorXYZ toXYZ(@NotNull SampledWavelengths lambdas) {
+        return lambdas.toXYZ(this);
+    }
+
+    public @NotNull Color toRGB(@NotNull SampledWavelengths lambdas, @NotNull ColorSpace cs) {
+        return cs.toRGB(toXYZ(lambdas));
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/SampledWavelengths.java

@@ -0,0 +1,93 @@
+package eu.jonahbauer.raytracing.render.spectral;
+
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorXYZ;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectra;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+
+/**
+ * A set of sampled wavelength that can be tracked together.
+ */
+public final class SampledWavelengths {
+    public static final int SAMPLES = 4;
+
+    private final double @NotNull[] lambdas;
+    private final double @NotNull[] pdf;
+
+    public static @NotNull SampledWavelengths uniform(double rng) {
+        return uniform(rng, Spectrum.LAMBDA_MIN, Spectrum.LAMBDA_MAX);
+    }
+
+    public static @NotNull SampledWavelengths uniform(double rng, double min, double max) {
+        var lambdas = new double[SAMPLES];
+
+        // choose first sample at random
+        lambdas[0] = (1 - rng) * min + rng * max;
+
+        // choose next samples in equal intervals, wrapping if necessary
+        var delta = (max - min) / SAMPLES;
+        for (int i = 1; i < SAMPLES; i++) {
+            lambdas[i] = lambdas[i - 1] + delta;
+            if (lambdas[i] > max) {
+                lambdas[i] = min + (lambdas[i] - max);
+            }
+        }
+
+        var pdf = new double[SAMPLES];
+        Arrays.fill(pdf, 1 / (max - min));
+        return new SampledWavelengths(lambdas, pdf);
+    }
+
+    private SampledWavelengths(double @NotNull[] lambdas, double @NotNull[] pdf) {
+        this.lambdas = lambdas;
+        this.pdf = pdf;
+    }
+
+    public double get(int index) {
+        return lambdas[index];
+    }
+
+    public int size() {
+        return lambdas.length;
+    }
+
+    /**
+     * Terminates the secondary wavelengths. This method should be called after a wavelength-dependent operation like
+     * refraction that makes it incorrect to track multiple wavelengths together.
+     */
+    public void terminateSecondary() {
+        if (pdf.length < 2 || pdf[1] == 0) return;
+        Arrays.fill(pdf, 1, pdf.length, 0d);
+        pdf[0] /= pdf.length;
+    }
+
+    @NotNull
+    ColorXYZ toXYZ(@NotNull SampledSpectrum spectrum) {
+        var x = Spectra.X.sample(this);
+        var y = Spectra.Y.sample(this);
+        var z = Spectra.Z.sample(this);
+
+        return new ColorXYZ(
+                toXYZ0(spectrum, x) / ColorXYZ.CIE_Y_INTEGRAL,
+                toXYZ0(spectrum, y) / ColorXYZ.CIE_Y_INTEGRAL,
+                toXYZ0(spectrum, z) / ColorXYZ.CIE_Y_INTEGRAL
+        );
+    }
+
+    private double toXYZ0(@NotNull SampledSpectrum spectrum, @NotNull SampledSpectrum cie) {
+        var avg = 0d;
+        for (int i = 0; i < spectrum.size(); i++) {
+            var pdf = this.pdf[i];
+            double value;
+            if (pdf == 0) {
+                value = 0;
+            } else {
+                value = spectrum.get(i) * cie.get(i) / pdf;
+            }
+            avg = Math.fma(1d / (i + 1), value - avg, avg);
+        }
+        return avg;
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/Chromaticity.java

@@ -0,0 +1,9 @@
+package eu.jonahbauer.raytracing.render.spectral.colors;
+
+/**
+ * A pair of chromaticity coordinates in the xyY color space
+ * @param x the x coordinate
+ * @param y the y coordinate
+ */
+public record Chromaticity(double x, double y) {
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/ColorSpace.java

@@ -0,0 +1,116 @@
+package eu.jonahbauer.raytracing.render.spectral.colors;
+
+import eu.jonahbauer.raytracing.math.Matrix3;
+import eu.jonahbauer.raytracing.math.Vec3;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.DenselySampledSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.texture.Color;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+/**
+ * An RGB color space.
+ */
+public final class ColorSpace {
+    private final @NotNull Chromaticity r;
+    private final @NotNull Chromaticity g;
+    private final @NotNull Chromaticity b;
+    private final @NotNull Chromaticity w;
+    private final @NotNull DenselySampledSpectrum illuminant;
+
+    private final @NotNull ColorXYZ R;
+    private final @NotNull ColorXYZ G;
+    private final @NotNull ColorXYZ B;
+    private final @NotNull ColorXYZ W;
+
+    private final @NotNull Matrix3 XYZfromRGB;
+    private final @NotNull Matrix3 RGBfromXYZ;
+    private final @NotNull SpectrumTable RGBtoSpectrumTable;
+
+    public ColorSpace(
+            @NotNull Chromaticity r, @NotNull Chromaticity g, @NotNull Chromaticity b,
+            @NotNull Spectrum illuminant, @NotNull SpectrumTable table
+    ) {
+        this.r = Objects.requireNonNull(r, "r");
+        this.g = Objects.requireNonNull(g, "g");
+        this.b = Objects.requireNonNull(b, "b");
+        this.illuminant = new DenselySampledSpectrum(illuminant);
+        this.RGBtoSpectrumTable = table;
+
+        this.W = illuminant.toXYZ();
+        this.w = W.xy();
+
+        this.R = new ColorXYZ(r);
+        this.G = new ColorXYZ(g);
+        this.B = new ColorXYZ(b);
+        var rgb = new Matrix3(
+                R.x(), G.x(), B.x(),
+                R.y(), G.y(), B.y(),
+                R.z(), G.z(), B.z()
+        );
+        var C = rgb.invert().times(W.toVec3());
+
+        this.XYZfromRGB = rgb.times(new Matrix3(C.x(), C.y(), C.z()));
+        this.RGBfromXYZ = XYZfromRGB.invert();
+    }
+
+    public @NotNull Color toRGB(@NotNull ColorXYZ xyz) {
+        var out = RGBfromXYZ.times(xyz.toVec3());
+        return new Color(out.x(), out.y(), out.z());
+    }
+
+    public @NotNull ColorXYZ toXYZ(@NotNull Color rgb) {
+        var out = XYZfromRGB.times(rgb.toVec3());
+        return new ColorXYZ(out);
+    }
+
+    public @NotNull Vec3 toCIELab(@NotNull Color rgb) {
+        return toCIELab(toXYZ(rgb));
+    }
+
+    public @NotNull Vec3 toCIELab(@NotNull ColorXYZ xyz) {
+        return new Vec3(
+                116 * cieLabCbrt(xyz.y() / W.y()) - 16,
+                500 * (cieLabCbrt(xyz.x() / W.x()) - cieLabCbrt(xyz.y() / W.y())),
+                200 * (cieLabCbrt(xyz.y() / W.y()) - cieLabCbrt(xyz.z() / W.z()))
+        );
+    }
+
+    private static double cieLabCbrt(double x) {
+        var delta = 6.0 / 29.0;
+        if (x > delta * delta * delta) {
+            return Math.cbrt(x);
+        } else {
+            return x / (delta * delta * 3.0) + (4.0 / 29.0);
+        }
+    }
+
+    public @NotNull SigmoidPolynomial toSpectrum(@NotNull Color rgb) {
+        return RGBtoSpectrumTable.get(new Color(
+                Math.max(0, rgb.r()),
+                Math.max(0, rgb.g()),
+                Math.max(0, rgb.b())
+        ));
+    }
+
+    public @NotNull Chromaticity r() {
+        return r;
+    }
+
+    public @NotNull Chromaticity g() {
+        return g;
+    }
+
+    public @NotNull Chromaticity b() {
+        return b;
+    }
+
+    public @NotNull Chromaticity w() {
+        return w;
+    }
+
+    public @NotNull DenselySampledSpectrum illuminant() {
+        return illuminant;
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/ColorSpaces.java

@@ -0,0 +1,44 @@
+package eu.jonahbauer.raytracing.render.spectral.colors;
+
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectra;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.Objects;
+
+public final class ColorSpaces {
+    // Rec. ITU-R BT.709.3
+    public static final @NotNull ColorSpace sRGB = new ColorSpace(
+            new Chromaticity(0.6400, 0.3300),
+            new Chromaticity(0.3000, 0.6000),
+            new Chromaticity(0.1500, 0.0600),
+            Spectra.D65, read("sRGB_spectrum.bin")
+    );
+    // P3-D65 (display)
+    public static final @NotNull ColorSpace DCI_P3 = new ColorSpace(
+            new Chromaticity(0.680, 0.320),
+            new Chromaticity(0.265, 0.690),
+            new Chromaticity(0.150, 0.060),
+            Spectra.D65, read("DCI_P3_spectrum.bin")
+    );
+    // ITU-R Rec BT.2020
+    public static final @NotNull ColorSpace Rec2020 = new ColorSpace(
+            new Chromaticity(0.708, 0.292),
+            new Chromaticity(0.170, 0.797),
+            new Chromaticity(0.131, 0.046),
+            Spectra.D65, read("Rec2020_spectrum.bin")
+    );
+
+    private static @NotNull SpectrumTable read(@NotNull String name) {
+        try (var in = ColorSpaces.class.getResourceAsStream("/eu/jonahbauer/raytracing/colorspace/" + name)) {
+            return SpectrumTable.read(Objects.requireNonNull(in));
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+    }
+
+    private ColorSpaces() {
+        throw new UnsupportedOperationException();
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/ColorXYZ.java

@@ -0,0 +1,52 @@
+package eu.jonahbauer.raytracing.render.spectral.colors;
+
+import eu.jonahbauer.raytracing.math.Vec3;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A CIE XYZ color
+ */
+public record ColorXYZ(double x, double y, double z) {
+    public static final double CIE_Y_INTEGRAL = 106.85689500000002;
+
+    public ColorXYZ(@NotNull Chromaticity chromaticity) {
+        this(chromaticity, 1);
+    }
+
+    public ColorXYZ(@NotNull Chromaticity chromaticity, double Y) {
+        this(
+                chromaticity.y() == 0 ? 0 : Y * chromaticity.x() / chromaticity.y(),
+                chromaticity.y() == 0 ? 0 : Y,
+                chromaticity.y() == 0 ? 0 : Y * (1 - chromaticity.x() - chromaticity.y()) / chromaticity.y()
+        );
+    }
+
+    public ColorXYZ(@NotNull Vec3 vec) {
+        this(vec.x(), vec.y(), vec.z());
+    }
+
+    public double average() {
+        return (x + y + z) / 3;
+    }
+
+    public @NotNull Chromaticity xy() {
+        var factor = 1 / (x + y + z);
+        return new Chromaticity(factor * x, factor * y);
+    }
+
+    public @NotNull Vec3 toVec3() {
+        return new Vec3(x, y, z);
+    }
+
+    public static @NotNull ColorXYZ multiply(@NotNull ColorXYZ a, @NotNull ColorXYZ b) {
+        return new ColorXYZ(a.x * b.x, a.y * b.y, a.z * b.z);
+    }
+
+    public static @NotNull ColorXYZ multiply(@NotNull ColorXYZ a, double b) {
+        return new ColorXYZ(a.x * b, a.y * b, a.z * b);
+    }
+
+    public static @NotNull ColorXYZ add(@NotNull ColorXYZ a, @NotNull ColorXYZ b) {
+        return new ColorXYZ(a.x + b.x, a.y + b.y, a.z + b.z);
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/SigmoidPolynomial.java

@@ -0,0 +1,34 @@
+package eu.jonahbauer.raytracing.render.spectral.colors;
+
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
+
+/**
+ * A function of the form {@code s(p(x))} where {@code p} is a polynomial of second degree and {@code s} is the sigmoid
+ * function <code>s(x) = 0.5 + x / (2 * sqrt(1 + x^2))</code>.
+ * <p>
+ * A function of this form is used to generate a {@link Spectrum} from an RGB value.
+ *
+ * @param c0 the coefficient of the quadratic term
+ * @param c1 the coefficient of the linear term
+ * @param c2 the coefficient of the constant term
+ */
+public record SigmoidPolynomial(double c0, double c1, double c2) {
+
+    public double get(double x) {
+        var p = Math.fma(Math.fma(c0, x, c1), x, c2);
+        if (!Double.isFinite(p)) return p > 0 ? 1 : 0;
+        return Math.fma(.5 * p, 1 / Math.sqrt(Math.fma(p, p, 1)), .5);
+    }
+
+    public double max() {
+        // evaluate at the edges
+        var result = Math.max(get(Spectrum.LAMBDA_MIN), get(Spectrum.LAMBDA_MAX));
+        var lambda = -c1 / (2 * c0);
+        if (lambda >= 360 && lambda <= 830) {
+            // evaluate at the vertex
+            return Math.max(result, get(lambda));
+        } else {
+            return result;
+        }
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/SpectrumTable.java

@@ -0,0 +1,143 @@
+package eu.jonahbauer.raytracing.render.spectral.colors;
+
+import eu.jonahbauer.raytracing.render.texture.Color;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.*;
+import java.util.Arrays;
+
+/**
+ * A table of sigmoid polynomials used to convert between RGB values and spectra.
+ * <p>
+ * The rgb values are renormalized to xyz coordinates with {@code z} being the largest of the rgb components, and
+ * {@code x} and {@code y} being the other two rgb components divided by {@code z}. By this construction, {@code x},
+ * {@code y} and {@code z} are all in the range [0, 1] which allows for better use of the samples in a fixed grid.
+ * The {@code z} coordinate is additionally remapped using {@link #zNodes} to improve sampling at both ends of the scale.
+ * <p>
+ * The coefficients of the sigmoid functions are stored in a flattened five-dimensional array with indices as described
+ * in {@link #coefficients}.
+ */
+public final class SpectrumTable {
+    private final int resolution;
+
+    /**
+     * the remapped {@code z} values
+     */
+    private final double[] zNodes;
+
+    /**
+     * the stored coefficients as a flattened five-dimensional array with the following indices
+     * <ol>
+     *     <li>the component index of the biggest rgb component</li>
+     *     <li>the {@code z} coordinate</li>
+     *     <li>the {@code y} coordinate</li>
+     *     <li>the {@code x} coordinate</li>
+     *     <li>the coefficient index</li>
+     * </ol>
+     */
+    private final double[] coefficients;
+
+    public static void write(@NotNull SpectrumTable table, @NotNull OutputStream out) throws IOException {
+        var dos = new DataOutputStream(out);
+        dos.writeInt(table.resolution);
+        for (double z : table.zNodes) {
+            dos.writeDouble(z);
+        }
+        for (double c : table.coefficients) {
+            dos.writeDouble(c);
+        }
+        dos.flush();
+    }
+
+    public static @NotNull SpectrumTable read(@NotNull InputStream in) throws IOException {
+        var dis = new DataInputStream(in);
+        var resolution = dis.readInt();
+        var nodes = new double[resolution];
+        for (int i = 0; i < resolution; i++) {
+            nodes[i] = dis.readDouble();
+        }
+        var table = new double[3 * resolution * resolution * resolution * 3];
+        for (int i = 0; i < table.length; i++) {
+            table[i] = dis.readDouble();
+        }
+        return new SpectrumTable(resolution, nodes, table);
+    }
+
+    SpectrumTable(int resolution, double @NotNull[] zNodes, double[] coefficients) {
+        this.resolution = resolution;
+        this.zNodes = zNodes;
+        this.coefficients = coefficients;
+
+        // check input array lengths
+        if (zNodes.length != resolution) {
+            throw new IllegalArgumentException("length of zNodes must be equal to the RESOLUTION");
+        }
+        if (coefficients.length != 3 * resolution * resolution * resolution * 3) {
+            throw new IllegalArgumentException("coefficients length must be 3 * RESOLUTION * RESOLUTION * RESOLUTION * 3");
+        }
+        // check ascending zNodes
+        for (int i = 1; i < resolution; i++) {
+            if (zNodes[i - 1] >= zNodes[i]) {
+                throw new IllegalArgumentException("zNodes must be in increasing order");
+            }
+        }
+        if (zNodes[0] != 0.0 || zNodes[zNodes.length - 1] != 1.0) {
+            throw new IllegalArgumentException("zNodes must start with 0.0 and end with 1.0");
+        }
+    }
+
+    public @NotNull SigmoidPolynomial get(@NotNull Color color) {
+        // handle uniform rgb values
+        if (color.r() == color.g() && color.g() == color.b()) {
+            return new SigmoidPolynomial(0, 0, (color.r() - .5) / Math.sqrt(color.r() * (1 - color.r())));
+        }
+
+        // find maximum component and compute remapped component values
+        var max = color.r() > color.g()
+                ? (color.r() > color.b() ? 0 : 2)
+                : (color.g() > color.b() ? 1 : 2);
+
+        var z = color.component(max);
+        var x = color.component((max + 1) % 3) * (resolution - 1) / z;
+        var y = color.component((max + 2) % 3) * (resolution - 1) / z;
+
+        // compute integer indices and offsets for coefficient interpolation
+        int xi = Math.min((int) x, resolution - 2);
+        int yi = Math.min((int) y, resolution - 2);
+        int zi = Arrays.binarySearch(zNodes, z);
+        if (zi < 0) {
+            zi = -zi - 2;
+        } else if (zi > 0) {
+            zi = zi - 1;
+        }
+
+        var dx = x - xi;
+        var dy = y -yi;
+        var dz = (z - zNodes[zi]) / (zNodes[zi + 1] - zNodes[zi]);
+
+        // trilinearly interpolate sigmoid polynomial coefficients
+        var c = new double[3];
+        for (int i = 0; i < 3; i++) {
+            c[i] = lerp(dz,
+                        lerp(dy,
+                             lerp(dx, get(max, zi + 0, yi + 0, xi + 0, i), get(max, zi + 0, yi + 0, xi + 1, i)),
+                             lerp(dx, get(max, zi + 0, yi + 1, xi + 0, i), get(max, zi + 0, yi + 1, xi + 1, i))
+                        ),
+                        lerp(dy,
+                             lerp(dx, get(max, zi + 1, yi + 0, xi + 0, i), get(max, zi + 1, yi + 0, xi + 1, i)),
+                             lerp(dx, get(max, zi + 1, yi + 1, xi + 0, i), get(max, zi + 1, yi + 1, xi + 1, i))
+                        )
+            );
+        }
+
+        return new SigmoidPolynomial(c[0], c[1], c[2]);
+    }
+
+    private double get(int l, int z, int y, int x, int i) {
+        return coefficients[(((l * resolution + z) * resolution + y) * resolution + x) * 3 + i];
+    }
+
+    private static double lerp(double t, double a, double b) {
+        return Math.fma(t, b, Math.fma(-t, a, a));
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/SpectrumTableGenerator.java

@@ -0,0 +1,205 @@
+package eu.jonahbauer.raytracing.render.spectral.colors;
+
+import eu.jonahbauer.raytracing.math.Matrix3;
+import eu.jonahbauer.raytracing.math.Vec3;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.texture.Color;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.stream.IntStream;
+
+/**
+ * Generates a lookup table for RGB to spectrum conversion.
+ * <p>
+ * The spectrum for each RGB value is a {@link SigmoidPolynomial} with coefficients such that the round trip error
+ * from converting the RGB value to a spectrum and back is minimized.
+ * <p>
+ * <img src="doc-files/rgb2spectrum.png">
+ */
+public final class SpectrumTableGenerator {
+    private static final double EPSILON = 1e-4;
+    private static final int ITERATIONS = 15;
+
+    private final int resolution = 64;
+    private final @NotNull ColorSpace cs;
+
+    public static void main(String[] args) throws IOException {
+        var generator = new SpectrumTableGenerator(ColorSpaces.DCI_P3);
+        var table = generator.generate();
+
+        try (var out = Files.newOutputStream(Path.of("DCI_P3_spectrum.bin"))) {
+            SpectrumTable.write(table, out);
+        }
+    }
+
+    public SpectrumTableGenerator(@NotNull ColorSpace cs) {
+        this.cs = Objects.requireNonNull(cs);
+    }
+
+    public @NotNull SpectrumTable generate() {
+        var scale = new double[resolution];
+        for (int i = 0; i < scale.length; i++) {
+            var t = (double) i / (resolution - 1);
+            scale[i] = smoothstep(smoothstep(t));
+        }
+
+        var table = new double[3 * resolution * resolution * resolution * 3];
+
+        for (int l0 = 0; l0 < 3; l0++) {
+            var l = l0;
+            IntStream.range(0, resolution).parallel().forEach(i -> {
+                System.out.println("l = " + l + ", i = " + i);
+                var x = (double) i / (resolution - 1);
+                for (int j = 0; j < resolution; j++) {
+                    var y = (double) j / (resolution - 1);
+
+                    var start = resolution / 5;
+
+                    var c = new double[3];
+                    for (int k = start; k < resolution; k++) {
+                        var z = scale[k];
+                        var idx = ((((l * resolution + k) * resolution) + j) * resolution + i) * 3;
+                        var color = getColor(l, x, y, z);
+                        generate(color, c, table, idx);
+                    }
+
+                    Arrays.fill(c, 0);
+                    for (int k = start; k >= 0; --k) {
+                        var z = scale[k];
+                        var idx = ((((l * resolution + k) * resolution) + j) * resolution + i) * 3;
+                        var color = getColor(l, x, y, z);
+                        generate(color, c, table, idx);
+                    }
+                }
+            });
+        }
+        return new SpectrumTable(resolution, scale, table);
+    }
+
+    private void generate(@NotNull Color rgb, double @NotNull[] c, double @NotNull[] out, int offset) {
+        gaussNewton(rgb, c, ITERATIONS);
+        double c0 = 360.0, c1 = 1.0 / (830.0 - 360.0);
+        double A = c[0], B = c[1], C = c[2];
+        out[offset] = A * c1 * c1;
+        out[offset + 1] = B * c1 - 2 * A * c0 * c1 * c1;
+        out[offset + 2] = C - B * c0 * c1 + A * c0 * c0 * c1 * c1;
+    }
+
+    /**
+     * Use Gauss-Newton algorithm to calculate coefficients {@code c} of a {@link SigmoidPolynomial} such that the round
+     * trip error from converting the {@code rgb} value to a spectrum and back is minimized.
+     * @param rgb the input color
+     * @param c the coefficients, used as initial values and output
+     * @param it the number of iterations
+     */
+    private void gaussNewton(@NotNull Color rgb, double @NotNull[] c, int it) {
+        var bestQuality = Double.POSITIVE_INFINITY;
+        var bestCoefficients = new double[3];
+
+        for (int i = 0; i < it; ++i) {
+            var polynomial = new SigmoidPolynomial(c[0], c[1], c[2]);
+            var residual = getResidual(rgb, polynomial);
+            var jacobian = getJacobian(rgb, polynomial);
+
+            var delta = jacobian.decompose(1e-15).solve(residual);
+            for (int j = 0; j < 3; ++j) {
+                c[j] -= delta.get(j);
+            }
+
+            // catch runaway
+            double max = Math.max(Math.max(c[0], c[1]), c[2]);
+            if (max > 200) {
+                for (int j = 0; j < 3; ++j) {
+                    c[j] *= 200 / max;
+                }
+            }
+
+            var quality = residual.squared();
+            if (quality <= 1e-6) {
+                return;
+            } else if (quality < bestQuality) {
+                bestQuality = quality;
+                System.arraycopy(c, 0, bestCoefficients, 0, 3);
+            }
+        }
+
+        System.arraycopy(bestCoefficients, 0, c, 0, 3);
+    }
+
+    /**
+     * Calculates the Jacobian matrix of the {@code polynomial}.
+     */
+    private @NotNull Matrix3 getJacobian(@NotNull Color rgb, @NotNull SigmoidPolynomial polynomial) {
+        var jac = new double[3][3];
+
+        // central finite difference coefficients for first derivative with sixth-order accuracy
+        var factors = new double[] { -1d/60, 3d/20, -3d/4, 0, 3d/4, -3d/20,	1d/60 };
+
+        for (int i = 0; i < 3; i++) {
+            var derivative = Vec3.ZERO;
+            for (int d = - factors.length / 2, j = 0; j < factors.length; d++, j++) {
+                if (factors[j] == 0) continue;
+                var tmp = switch (i) {
+                    case 0 -> new SigmoidPolynomial(polynomial.c0() + d * EPSILON, polynomial.c1(), polynomial.c2());
+                    case 1 -> new SigmoidPolynomial(polynomial.c0(), polynomial.c1() + d * EPSILON, polynomial.c2());
+                    case 2 -> new SigmoidPolynomial(polynomial.c0(), polynomial.c1(), polynomial.c2() + d * EPSILON);
+                    default -> throw new AssertionError();
+                };
+                var r = getResidual(rgb, tmp);
+                derivative = Vec3.fma(factors[j], r, derivative);
+            }
+
+            for (int j = 0; j < 3; j++) {
+                jac[j][i] = derivative.get(j) / EPSILON;
+            }
+        }
+
+        return new Matrix3(
+                jac[0][0], jac[0][1], jac[0][2],
+                jac[1][0], jac[1][1], jac[1][2],
+                jac[2][0], jac[2][1], jac[2][2]
+        );
+    }
+
+    /**
+     * Calculates the difference between the RGB color and the result of converting the RGB color to a spectrum using
+     * the given coefficients, illuminating it with the color space's standard illuminant, and converting it back to an
+     * RBG color. The output is a vector in CIE Lab color space.
+     */
+    private @NotNull Vec3 getResidual(@NotNull Color rgb, @NotNull SigmoidPolynomial polynomial) {
+        var out = new SigmoidPolynomialSpectrum(polynomial, cs).toXYZ();
+        return cs.toCIELab(rgb).minus(cs.toCIELab(out));
+    }
+
+
+    private static double smoothstep(double x) {
+        return x * x * (3.0 - 2.0 * x);
+    }
+
+    private static @NotNull Color getColor(int l, double x, double y, double z) {
+        var rgb = new double[3];
+        rgb[l] = z;
+        rgb[(l + 1) % 3] = x * z;
+        rgb[(l + 2) % 3] = y * z;
+        return new Color(rgb[0], rgb[1], rgb[2]);
+    }
+
+    private record SigmoidPolynomialSpectrum(@NotNull SigmoidPolynomial polynomial, @NotNull ColorSpace cs) implements Spectrum {
+
+        @Override
+        public double max() {
+            return polynomial.max();
+        }
+
+        @Override
+        public double get(double lambda) {
+            var l = (lambda - Spectrum.LAMBDA_MIN) / (Spectrum.LAMBDA_MAX - Spectrum.LAMBDA_MIN);
+            return polynomial.get(l) * cs.illuminant().get(lambda);
+        }
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/BlackbodySpectrum.java

@@ -0,0 +1,45 @@
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
+
+public final class BlackbodySpectrum implements Spectrum {
+    /**
+     * the speed of light in m/s
+     */
+    private static final double c = 299792458d;
+
+    /**
+     * the planck constant in m^2*kg/s
+     */
+    private static final double h = 6.62607015E-34;
+
+    /**
+     * the boltzmann constant in m^2*kg/s^2/K
+     */
+    private static final double k = 1.380649E-23;
+
+    /**
+     * wien's displacement constant in m*K
+     */
+    private static final double b = 2.897771995E-3;
+
+    private final double T;
+    private final double factor;
+
+    public BlackbodySpectrum(double T) {
+        if (T < 0) throw new IllegalArgumentException("T must be non-negative");
+        this.T = T;
+        this.factor = 1 / get(b / T);
+    }
+
+    @Override
+    public double max() {
+        return 1;
+    }
+
+    @Override
+    public double get(double lambda) {
+        lambda *= 1E-9;
+        var l2 = lambda * lambda;
+        var x = h * c / (lambda * k * T);
+        return 2 * h * c * c / (l2 * l2 * lambda) / (Math.exp(x) - 1) * factor;
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/ConstantSpectrum.java

@@ -0,0 +1,17 @@
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
+
+/**
+ * A constant spectrum.
+ * @param c the constant value
+ */
+public record ConstantSpectrum(double c) implements Spectrum {
+    @Override
+    public double max() {
+        return c;
+    }
+
+    @Override
+    public double get(double lambda) {
+        return c;
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/DenselySampledSpectrum.java

@@ -0,0 +1,59 @@
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+
+/**
+ * A spectrum sampled in one nanometer intervals.
+ */
+public final class DenselySampledSpectrum implements Spectrum {
+    private final double[] samples;
+    private final int min;
+
+    private final double max;
+
+    public DenselySampledSpectrum(@NotNull Spectrum spectrum) {
+        this(spectrum, LAMBDA_MIN, LAMBDA_MAX);
+    }
+
+    public DenselySampledSpectrum(@NotNull Spectrum spectrum, int min, int max) {
+        if (max - min + 1 <= 0) throw new IllegalArgumentException("samples must not be empty");
+        this.samples = new double[max - min + 1];
+        var maxValue = 0d;
+        for (int lambda = min, i = 0; lambda <= max; lambda++, i++) {
+            var sample = spectrum.get(lambda);
+            if (sample > maxValue) maxValue = sample;
+            this.samples[i] = sample;
+        }
+        this.min = min;
+        this.max = maxValue;
+    }
+
+    public DenselySampledSpectrum(double @NotNull[] samples, int lambdaMin) {
+        if (samples.length == 0) throw new IllegalArgumentException("samples must not be empty");
+        this.samples = Arrays.copyOf(samples, samples.length);
+        this.min = lambdaMin;
+        this.max = Arrays.stream(this.samples).max().orElseThrow();
+    }
+
+    public @NotNull DenselySampledSpectrum scale(double scale) {
+        var s = Arrays.copyOf(samples, samples.length);
+        for (int i = 0; i < s.length; i++) {
+            s[i] *= scale;
+        }
+        return new DenselySampledSpectrum(s, min);
+    }
+
+    @Override
+    public double max() {
+        return max;
+    }
+
+    @Override
+    public double get(double lambda) {
+        int offset = (int) Math.round(lambda) - min;
+        if (offset < 0 || offset >= samples.length) return 0;
+        return samples[offset];
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/PiecewiseLinearSpectrum.java

@@ -0,0 +1,58 @@
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+
+public final class PiecewiseLinearSpectrum implements Spectrum {
+    private final double[] lambdas;
+    private final double[] values;
+    private final double max;
+
+    public PiecewiseLinearSpectrum(double[] lambdas, double[] values) {
+        if (lambdas.length != values.length) {
+            throw new IllegalArgumentException("lambdas and values must have the same length");
+        }
+
+        this.lambdas = Arrays.copyOf(lambdas, lambdas.length);
+        this.values = Arrays.copyOf(values, values.length);
+
+        var max = 0d;
+        for (int i = 1; i < this.lambdas.length; i++) {
+            if (this.lambdas[i] <= this.lambdas[i - 1]) {
+                throw new IllegalArgumentException("lambdas must be in increasing order");
+            }
+            if (this.values[i] < 0) {
+                throw new IllegalArgumentException("values must be non-negative");
+            } else if (this.values[i] > max) {
+                max = this.values[i];
+            }
+        }
+        this.max = max;
+    }
+
+    public @NotNull PiecewiseLinearSpectrum scale(double scale) {
+        var v = Arrays.copyOf(values, values.length);
+        for (int i = 0; i < v.length; i++) {
+            v[i] *= scale;
+        }
+        return new PiecewiseLinearSpectrum(lambdas, v);
+    }
+
+    @Override
+    public double max() {
+        return max;
+    }
+
+    @Override
+    public double get(double lambda) {
+        if (lambdas.length == 0 || lambda < lambdas[0] || lambda > lambdas[lambdas.length - 1]) return 0;
+        if (lambda == lambdas[lambdas.length - 1]) return values[values.length - 1];
+
+        var i = Arrays.binarySearch(lambdas, lambda);
+        if (i < 0) i = -i - 1;
+
+        var t = (lambda - lambdas[i]) / (lambdas[i + 1] - lambdas[i]);
+        return (1 - t) * values[i] + t * values[i + 1];
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/RGBAlbedoSpectrum.java

@@ -0,0 +1,27 @@
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
+
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.SigmoidPolynomial;
+import eu.jonahbauer.raytracing.render.texture.Color;
+import org.jetbrains.annotations.NotNull;
+
+public final class RGBAlbedoSpectrum implements Spectrum {
+    private final @NotNull SigmoidPolynomial polynomial;
+
+    public RGBAlbedoSpectrum(@NotNull ColorSpace cs, @NotNull Color rgb) {
+        if (rgb.r() < 0 || rgb.r() > 1 || rgb.g() < 0 || rgb.g() > 1 || rgb.b() < 0 || rgb.b() > 1) {
+            throw new IllegalArgumentException();
+        }
+        this.polynomial = cs.toSpectrum(rgb);
+    }
+
+    @Override
+    public double max() {
+        return polynomial.max();
+    }
+
+    @Override
+    public double get(double lambda) {
+        return polynomial.get(lambda);
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/RGBIlluminantSpectrum.java

@@ -0,0 +1,36 @@
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
+
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.SigmoidPolynomial;
+import eu.jonahbauer.raytracing.render.texture.Color;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A spectrum based on an RGB color used as an illuminant. The spectrum is adjusted to account for the color space's
+ * standard illuminant.
+ */
+public final class RGBIlluminantSpectrum implements Spectrum {
+    private final double scale;
+    private final @NotNull SigmoidPolynomial polynomial;
+    private final @NotNull Spectrum illuminant;
+
+    public RGBIlluminantSpectrum(@NotNull ColorSpace cs, @NotNull Color rgb) {
+        if (rgb.r() < 0 || rgb.g() < 0 || rgb.b() < 0) {
+            throw new IllegalArgumentException();
+        }
+        var max = Math.max(rgb.r(), Math.max(rgb.g(), rgb.b()));
+        this.scale = 2 * max;
+        this.polynomial = cs.toSpectrum(scale == 0 ? Color.multiply(rgb, scale) : Color.BLACK);
+        this.illuminant = cs.illuminant();
+    }
+
+    @Override
+    public double max() {
+        return scale * polynomial.max() * illuminant.max();
+    }
+
+    @Override
+    public double get(double lambda) {
+        return scale * polynomial.get(lambda) * illuminant.get(lambda);
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/RGBUnboundedSpectrum.java

@@ -0,0 +1,30 @@
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
+
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.SigmoidPolynomial;
+import eu.jonahbauer.raytracing.render.texture.Color;
+import org.jetbrains.annotations.NotNull;
+
+public final class RGBUnboundedSpectrum implements Spectrum {
+    private final double scale;
+    private final @NotNull SigmoidPolynomial polynomial;
+
+    public RGBUnboundedSpectrum(@NotNull ColorSpace cs, @NotNull Color rgb) {
+        if (rgb.r() < 0 || rgb.g() < 0 || rgb.b() < 0) {
+            throw new IllegalArgumentException();
+        }
+        var max = Math.max(rgb.r(), Math.max(rgb.g(), rgb.b()));
+        this.scale = 2 * max;
+        this.polynomial = cs.toSpectrum(scale == 0 ? Color.multiply(rgb, scale) : Color.BLACK);
+    }
+
+    @Override
+    public double max() {
+        return scale * polynomial.max();
+    }
+
+    @Override
+    public double get(double lambda) {
+        return scale * polynomial.get(lambda);
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/Spectra.java

@@ -0,0 +1,407 @@
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
+
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorXYZ;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.UncheckedIOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+
+public final class Spectra {
+    private static final String PATH_PREFIX = "/eu/jonahbauer/raytracing/spectrum/";
+
+    /**
+     * the CIE XYZ color matching curve for X
+     */
+    public static final Spectrum X = new DenselySampledSpectrum(new PiecewiseLinearSpectrum(CIE_XYZ.CIE_lambda, CIE_XYZ.CIE_X));
+    /**
+     * the CIE XYZ color matching curve for Y
+     */
+    public static final Spectrum Y = new DenselySampledSpectrum(new PiecewiseLinearSpectrum(CIE_XYZ.CIE_lambda, CIE_XYZ.CIE_Y));;
+    /**
+     * the CIE XYZ color matching curve for Z
+     */
+    public static final Spectrum Z = new DenselySampledSpectrum(new PiecewiseLinearSpectrum(CIE_XYZ.CIE_lambda, CIE_XYZ.CIE_Z));;
+    /**
+     * the CIE standard illuminant D50
+     * @see <a href="https://doi.org/10.25039/CIE.DS.hjfjmt59">CIE 2022, CIE standard illuminant D65, International Commission on Illumination (CIE), Vienna, Austria, DOI: 10.25039/CIE.DS.hjfjmt59</a>
+     */
+    public static final Spectrum D50 = read("CIE_std_illum_D50.csv", true);
+    /**
+     * the CIE standard illuminant D65
+     * @see <a href="https://doi.org/10.25039/CIE.DS.etgmuqt5">CIE 2022, Relative spectral power distributions of CIE standard illuminants A, D65 and D50 (wavelengths in standard air) (data table), International Commission on Illumination (CIE), Vienna, Austria, DOI:10.25039/CIE.DS.etgmuqt5</a>
+     */
+    public static final Spectrum D65 = read("CIE_std_illum_D65.csv", true);
+
+    private static @NotNull Spectrum read(@NotNull String path, boolean normalize) {
+        var lambda = new ArrayList<Double>();
+        var values = new ArrayList<Double>();
+
+        try (
+                var is = Spectra.class.getResourceAsStream(PATH_PREFIX + path);
+                var in = new BufferedReader(new InputStreamReader(is, StandardCharsets.US_ASCII))
+        ) {
+            String line;
+            while ((line = in.readLine()) != null) {
+                var parts = line.split(",");
+                lambda.add(Double.parseDouble(parts[0]));
+                values.add(Double.parseDouble(parts[1]));
+            }
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+
+        var pls = new PiecewiseLinearSpectrum(
+                lambda.stream().mapToDouble(Double::doubleValue).toArray(),
+                values.stream().mapToDouble(Double::doubleValue).toArray()
+        );
+        if (normalize) {
+            return pls.scale(ColorXYZ.CIE_Y_INTEGRAL / Util.innerProduct(pls, Spectra.Y));
+        } else {
+            return pls;
+        }
+    }
+
+    private Spectra() {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * @see <a href="https://doi.org/10.25039/CIE.DS.xvudnb9b">CIE 2018, CIE 1931 colour-matching functions , 2 degree observer (data table),
+     * International Commission on Illumination (CIE), Vienna, Austria,
+     * DOI:10.25039/CIE.DS.xvudnb9b</a>
+     */
+    private static final class CIE_XYZ {
+        private static final double[] CIE_lambda = {
+                360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376,
+                377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393,
+                394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410,
+                411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427,
+                428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444,
+                445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461,
+                462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478,
+                479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495,
+                496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
+                513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529,
+                530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546,
+                547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563,
+                564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580,
+                581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597,
+                598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614,
+                615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631,
+                632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648,
+                649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665,
+                666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682,
+                683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699,
+                700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716,
+                717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733,
+                734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750,
+                751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767,
+                768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784,
+                785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, 801,
+                802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818,
+                819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830
+        };
+
+
+        private static final double[] CIE_X = {
+                // CIE X function values
+                0.0001299000,   0.0001458470,   0.0001638021,   0.0001840037,   0.0002066902,
+                0.0002321000,   0.0002607280,   0.0002930750,   0.0003293880,   0.0003699140,
+                0.0004149000,   0.0004641587,   0.0005189860,   0.0005818540,   0.0006552347,
+                0.0007416000,   0.0008450296,   0.0009645268,   0.001094949,    0.001231154,
+                0.001368000,    0.001502050,    0.001642328,    0.001802382,    0.001995757,
+                0.002236000,    0.002535385,    0.002892603,    0.003300829,    0.003753236,
+                0.004243000,    0.004762389,    0.005330048,    0.005978712,    0.006741117,
+                0.007650000,    0.008751373,    0.01002888,     0.01142170,     0.01286901,
+                0.01431000,     0.01570443,     0.01714744,     0.01878122,     0.02074801,
+                0.02319000,     0.02620736,     0.02978248,     0.03388092,     0.03846824,
+                0.04351000,     0.04899560,     0.05502260,     0.06171880,     0.06921200,
+                0.07763000,     0.08695811,     0.09717672,     0.1084063,      0.1207672,
+                0.1343800,      0.1493582,      0.1653957,      0.1819831,      0.1986110,
+                0.2147700,      0.2301868,      0.2448797,      0.2587773,      0.2718079,
+                0.2839000,      0.2949438,      0.3048965,      0.3137873,      0.3216454,
+                0.3285000,      0.3343513,      0.3392101,      0.3431213,      0.3461296,
+                0.3482800,      0.3495999,      0.3501474,      0.3500130,      0.3492870,
+                0.3480600,      0.3463733,      0.3442624,      0.3418088,      0.3390941,
+                0.3362000,      0.3331977,      0.3300411,      0.3266357,      0.3228868,
+                0.3187000,      0.3140251,      0.3088840,      0.3032904,      0.2972579,
+                0.2908000,      0.2839701,      0.2767214,      0.2689178,      0.2604227,
+                0.2511000,      0.2408475,      0.2298512,      0.2184072,      0.2068115,
+                0.1953600,      0.1842136,      0.1733273,      0.1626881,      0.1522833,
+                0.1421000,      0.1321786,      0.1225696,      0.1132752,      0.1042979,
+                0.09564000,     0.08729955,     0.07930804,     0.07171776,     0.06458099,
+                0.05795001,     0.05186211,     0.04628152,     0.04115088,     0.03641283,
+                0.03201000,     0.02791720,     0.02414440,     0.02068700,     0.01754040,
+                0.01470000,     0.01216179,     0.009919960,    0.007967240,    0.006296346,
+                0.004900000,    0.003777173,    0.002945320,    0.002424880,    0.002236293,
+                0.002400000,    0.002925520,    0.003836560,    0.005174840,    0.006982080,
+                0.009300000,    0.01214949,     0.01553588,     0.01947752,     0.02399277,
+                0.02910000,     0.03481485,     0.04112016,     0.04798504,     0.05537861,
+                0.06327000,     0.07163501,     0.08046224,     0.08973996,     0.09945645,
+                0.1096000,      0.1201674,      0.1311145,      0.1423679,      0.1538542,
+                0.1655000,      0.1772571,      0.1891400,      0.2011694,      0.2133658,
+                0.2257499,      0.2383209,      0.2510668,      0.2639922,      0.2771017,
+                0.2904000,      0.3038912,      0.3175726,      0.3314384,      0.3454828,
+                0.3597000,      0.3740839,      0.3886396,      0.4033784,      0.4183115,
+                0.4334499,      0.4487953,      0.4643360,      0.4800640,      0.4959713,
+                0.5120501,      0.5282959,      0.5446916,      0.5612094,      0.5778215,
+                0.5945000,      0.6112209,      0.6279758,      0.6447602,      0.6615697,
+                0.6784000,      0.6952392,      0.7120586,      0.7288284,      0.7455188,
+                0.7621000,      0.7785432,      0.7948256,      0.8109264,      0.8268248,
+                0.8425000,      0.8579325,      0.8730816,      0.8878944,      0.9023181,
+                0.9163000,      0.9297995,      0.9427984,      0.9552776,      0.9672179,
+                0.9786000,      0.9893856,      0.9995488,      1.0090892,      1.0180064,
+                1.0263000,      1.0339827,      1.0409860,      1.0471880,      1.0524667,
+                1.0567000,      1.0597944,      1.0617992,      1.0628068,      1.0629096,
+                1.0622000,      1.0607352,      1.0584436,      1.0552244,      1.0509768,
+                1.0456000,      1.0390369,      1.0313608,      1.0226662,      1.0130477,
+                1.0026000,      0.9913675,      0.9793314,      0.9664916,      0.9528479,
+                0.9384000,      0.9231940,      0.9072440,      0.8905020,      0.8729200,
+                0.8544499,      0.8350840,      0.8149460,      0.7941860,      0.7729540,
+                0.7514000,      0.7295836,      0.7075888,      0.6856022,      0.6638104,
+                0.6424000,      0.6215149,      0.6011138,      0.5811052,      0.5613977,
+                0.5419000,      0.5225995,      0.5035464,      0.4847436,      0.4661939,
+                0.4479000,      0.4298613,      0.4120980,      0.3946440,      0.3775333,
+                0.3608000,      0.3444563,      0.3285168,      0.3130192,      0.2980011,
+                0.2835000,      0.2695448,      0.2561184,      0.2431896,      0.2307272,
+                0.2187000,      0.2070971,      0.1959232,      0.1851708,      0.1748323,
+                0.1649000,      0.1553667,      0.1462300,      0.1374900,      0.1291467,
+                0.1212000,      0.1136397,      0.1064650,      0.09969044,     0.09333061,
+                0.08740000,     0.08190096,     0.07680428,     0.07207712,     0.06768664,
+                0.06360000,     0.05980685,     0.05628216,     0.05297104,     0.04981861,
+                0.04677000,     0.04378405,     0.04087536,     0.03807264,     0.03540461,
+                0.03290000,     0.03056419,     0.02838056,     0.02634484,     0.02445275,
+                0.02270000,     0.02108429,     0.01959988,     0.01823732,     0.01698717,
+                0.01584000,     0.01479064,     0.01383132,     0.01294868,     0.01212920,
+                0.01135916,     0.01062935,     0.009938846,    0.009288422,    0.008678854,
+                0.008110916,    0.007582388,    0.007088746,    0.006627313,    0.006195408,
+                0.005790346,    0.005409826,    0.005052583,    0.004717512,    0.004403507,
+                0.004109457,    0.003833913,    0.003575748,    0.003334342,    0.003109075,
+                0.002899327,    0.002704348,    0.002523020,    0.002354168,    0.002196616,
+                0.002049190,    0.001910960,    0.001781438,    0.001660110,    0.001546459,
+                0.001439971,    0.001340042,    0.001246275,    0.001158471,    0.001076430,
+                0.0009999493,   0.0009287358,   0.0008624332,   0.0008007503,   0.0007433960,
+                0.0006900786,   0.0006405156,   0.0005945021,   0.0005518646,   0.0005124290,
+                0.0004760213,   0.0004424536,   0.0004115117,   0.0003829814,   0.0003566491,
+                0.0003323011,   0.0003097586,   0.0002888871,   0.0002695394,   0.0002515682,
+                0.0002348261,   0.0002191710,   0.0002045258,   0.0001908405,   0.0001780654,
+                0.0001661505,   0.0001550236,   0.0001446219,   0.0001349098,   0.0001258520,
+                0.0001174130,   0.0001095515,   0.0001022245,   0.00009539445,  0.00008902390,
+                0.00008307527,  0.00007751269,  0.00007231304,  0.00006745778,  0.00006292844,
+                0.00005870652,  0.00005477028,  0.00005109918,  0.00004767654,  0.00004448567,
+                0.00004150994,  0.00003873324,  0.00003614203,  0.00003372352,  0.00003146487,
+                0.00002935326,  0.00002737573,  0.00002552433,  0.00002379376,  0.00002217870,
+                0.00002067383,  0.00001927226,  0.00001796640,  0.00001674991,  0.00001561648,
+                0.00001455977,  0.00001357387,  0.00001265436,  0.00001179723,  0.00001099844,
+                0.00001025398,  0.000009559646, 0.000008912044, 0.000008308358, 0.000007745769,
+                0.000007221456, 0.000006732475, 0.000006276423, 0.000005851304, 0.000005455118,
+                0.000005085868, 0.000004741466, 0.000004420236, 0.000004120783, 0.000003841716,
+                0.000003581652, 0.000003339127, 0.000003112949, 0.000002902121, 0.000002705645,
+                0.000002522525, 0.000002351726, 0.000002192415, 0.000002043902, 0.000001905497,
+                0.000001776509, 0.000001656215, 0.000001544022, 0.000001439440, 0.000001341977,
+                0.000001251141
+        };
+
+        private static final double[] CIE_Y = {
+                // CIE Y function values
+                0.000003917000,  0.000004393581,  0.000004929604,  0.000005532136,  0.000006208245,
+                0.000006965000,  0.000007813219,  0.000008767336,  0.000009839844,  0.00001104323,
+                0.00001239000,   0.00001388641,   0.00001555728,   0.00001744296,   0.00001958375,
+                0.00002202000,   0.00002483965,   0.00002804126,   0.00003153104,   0.00003521521,
+                0.00003900000,   0.00004282640,   0.00004691460,   0.00005158960,   0.00005717640,
+                0.00006400000,   0.00007234421,   0.00008221224,   0.00009350816,   0.0001061361,
+                0.0001200000,    0.0001349840,    0.0001514920,    0.0001702080,    0.0001918160,
+                0.0002170000,    0.0002469067,    0.0002812400,    0.0003185200,    0.0003572667,
+                0.0003960000,    0.0004337147,    0.0004730240,    0.0005178760,    0.0005722187,
+                0.0006400000,    0.0007245600,    0.0008255000,    0.0009411600,    0.001069880,
+                0.001210000,     0.001362091,     0.001530752,     0.001720368,     0.001935323,
+                0.002180000,     0.002454800,     0.002764000,     0.003117800,     0.003526400,
+                0.004000000,     0.004546240,     0.005159320,     0.005829280,     0.006546160,
+                0.007300000,     0.008086507,     0.008908720,     0.009767680,     0.01066443,
+                0.01160000,      0.01257317,      0.01358272,      0.01462968,      0.01571509,
+                0.01684000,      0.01800736,      0.01921448,      0.02045392,      0.02171824,
+                0.02300000,      0.02429461,      0.02561024,      0.02695857,      0.02835125,
+                0.02980000,      0.03131083,      0.03288368,      0.03452112,      0.03622571,
+                0.03800000,      0.03984667,      0.04176800,      0.04376600,      0.04584267,
+                0.04800000,      0.05024368,      0.05257304,      0.05498056,      0.05745872,
+                0.06000000,      0.06260197,      0.06527752,      0.06804208,      0.07091109,
+                0.07390000,      0.07701600,      0.08026640,      0.08366680,      0.08723280,
+                0.09098000,      0.09491755,      0.09904584,      0.1033674,       0.1078846,
+                0.1126000,       0.1175320,       0.1226744,       0.1279928,       0.1334528,
+                0.1390200,       0.1446764,       0.1504693,       0.1564619,       0.1627177,
+                0.1693000,       0.1762431,       0.1835581,       0.1912735,       0.1994180,
+                0.2080200,       0.2171199,       0.2267345,       0.2368571,       0.2474812,
+                0.2586000,       0.2701849,       0.2822939,       0.2950505,       0.3085780,
+                0.3230000,       0.3384021,       0.3546858,       0.3716986,       0.3892875,
+                0.4073000,       0.4256299,       0.4443096,       0.4633944,       0.4829395,
+                0.5030000,       0.5235693,       0.5445120,       0.5656900,       0.5869653,
+                0.6082000,       0.6293456,       0.6503068,       0.6708752,       0.6908424,
+                0.7100000,       0.7281852,       0.7454636,       0.7619694,       0.7778368,
+                0.7932000,       0.8081104,       0.8224962,       0.8363068,       0.8494916,
+                0.8620000,       0.8738108,       0.8849624,       0.8954936,       0.9054432,
+                0.9148501,       0.9237348,       0.9320924,       0.9399226,       0.9472252,
+                0.9540000,       0.9602561,       0.9660074,       0.9712606,       0.9760225,
+                0.9803000,       0.9840924,       0.9874812,       0.9903128,       0.9928116,
+                0.9949501,       0.9967108,       0.9980983,       0.9991120,       0.9997482,
+                1.0000000,       0.9998567,       0.9993046,       0.9983255,       0.9968987,
+                0.9950000,       0.9926005,       0.9897426,       0.9864444,       0.9827241,
+                0.9786000,       0.9740837,       0.9691712,       0.9638568,       0.9581349,
+                0.9520000,       0.9454504,       0.9384992,       0.9311628,       0.9234576,
+                0.9154000,       0.9070064,       0.8982772,       0.8892048,       0.8797816,
+                0.8700000,       0.8598613,       0.8493920,       0.8386220,       0.8275813,
+                0.8163000,       0.8047947,       0.7930820,       0.7811920,       0.7691547,
+                0.7570000,       0.7447541,       0.7324224,       0.7200036,       0.7074965,
+                0.6949000,       0.6822192,       0.6694716,       0.6566744,       0.6438448,
+                0.6310000,       0.6181555,       0.6053144,       0.5924756,       0.5796379,
+                0.5668000,       0.5539611,       0.5411372,       0.5283528,       0.5156323,
+                0.5030000,       0.4904688,       0.4780304,       0.4656776,       0.4534032,
+                0.4412000,       0.4290800,       0.4170360,       0.4050320,       0.3930320,
+                0.3810000,       0.3689184,       0.3568272,       0.3447768,       0.3328176,
+                0.3210000,       0.3093381,       0.2978504,       0.2865936,       0.2756245,
+                0.2650000,       0.2547632,       0.2448896,       0.2353344,       0.2260528,
+                0.2170000,       0.2081616,       0.1995488,       0.1911552,       0.1829744,
+                0.1750000,       0.1672235,       0.1596464,       0.1522776,       0.1451259,
+                0.1382000,       0.1315003,       0.1250248,       0.1187792,       0.1127691,
+                0.1070000,       0.1014762,       0.09618864,      0.09112296,      0.08626485,
+                0.08160000,      0.07712064,      0.07282552,      0.06871008,      0.06476976,
+                0.06100000,      0.05739621,      0.05395504,      0.05067376,      0.04754965,
+                0.04458000,      0.04175872,      0.03908496,      0.03656384,      0.03420048,
+                0.03200000,      0.02996261,      0.02807664,      0.02632936,      0.02470805,
+                0.02320000,      0.02180077,      0.02050112,      0.01928108,      0.01812069,
+                0.01700000,      0.01590379,      0.01483718,      0.01381068,      0.01283478,
+                0.01192000,      0.01106831,      0.01027339,      0.009533311,     0.008846157,
+                0.008210000,     0.007623781,     0.007085424,     0.006591476,     0.006138485,
+                0.005723000,     0.005343059,     0.004995796,     0.004676404,     0.004380075,
+                0.004102000,     0.003838453,     0.003589099,     0.003354219,     0.003134093,
+                0.002929000,     0.002738139,     0.002559876,     0.002393244,     0.002237275,
+                0.002091000,     0.001953587,     0.001824580,     0.001703580,     0.001590187,
+                0.001484000,     0.001384496,     0.001291268,     0.001204092,     0.001122744,
+                0.001047000,     0.0009765896,    0.0009111088,    0.0008501332,    0.0007932384,
+                0.0007400000,    0.0006900827,    0.0006433100,    0.0005994960,    0.0005584547,
+                0.0005200000,    0.0004839136,    0.0004500528,    0.0004183452,    0.0003887184,
+                0.0003611000,    0.0003353835,    0.0003114404,    0.0002891656,    0.0002684539,
+                0.0002492000,    0.0002313019,    0.0002146856,    0.0001992884,    0.0001850475,
+                0.0001719000,    0.0001597781,    0.0001486044,    0.0001383016,    0.0001287925,
+                0.0001200000,    0.0001118595,    0.0001043224,    0.00009733560,   0.00009084587,
+                0.00008480000,   0.00007914667,   0.00007385800,   0.00006891600,   0.00006430267,
+                0.00006000000,   0.00005598187,   0.00005222560,   0.00004871840,   0.00004544747,
+                0.00004240000,   0.00003956104,   0.00003691512,   0.00003444868,   0.00003214816,
+                0.00003000000,   0.00002799125,   0.00002611356,   0.00002436024,   0.00002272461,
+                0.00002120000,   0.00001977855,   0.00001845285,   0.00001721687,   0.00001606459,
+                0.00001499000,   0.00001398728,   0.00001305155,   0.00001217818,   0.00001136254,
+                0.00001060000,   0.000009885877,  0.000009217304,  0.000008592362,  0.000008009133,
+                0.000007465700,  0.000006959567,  0.000006487995,  0.000006048699,  0.000005639396,
+                0.000005257800,  0.000004901771,  0.000004569720,  0.000004260194,  0.000003971739,
+                0.000003702900,  0.000003452163,  0.000003218302,  0.000003000300,  0.000002797139,
+                0.000002607800,  0.000002431220,  0.000002266531,  0.000002113013,  0.000001969943,
+                0.000001836600,  0.000001712230,  0.000001596228,  0.000001488090,  0.000001387314,
+                0.000001293400,  0.000001205820,  0.000001124143,  0.000001048009,  0.0000009770578,
+                0.0000009109300, 0.0000008492513, 0.0000007917212, 0.0000007380904, 0.0000006881098,
+                0.0000006415300, 0.0000005980895, 0.0000005575746, 0.0000005198080, 0.0000004846123,
+                0.0000004518100
+        };
+
+        private static final double[] CIE_Z = {
+                // CIE Z function values
+                0.0006061000,   0.0006808792,   0.0007651456,   0.0008600124,   0.0009665928,
+                0.001086000,    0.001220586,    0.001372729,    0.001543579,    0.001734286,
+                0.001946000,    0.002177777,    0.002435809,    0.002731953,    0.003078064,
+                0.003486000,    0.003975227,    0.004540880,    0.005158320,    0.005802907,
+                0.006450001,    0.007083216,    0.007745488,    0.008501152,    0.009414544,
+                0.01054999,     0.01196580,     0.01365587,     0.01558805,     0.01773015,
+                0.02005001,     0.02251136,     0.02520288,     0.02827972,     0.03189704,
+                0.03621000,     0.04143771,     0.04750372,     0.05411988,     0.06099803,
+                0.06785001,     0.07448632,     0.08136156,     0.08915364,     0.09854048,
+                0.1102000,      0.1246133,      0.1417017,      0.1613035,      0.1832568,
+                0.2074000,      0.2336921,      0.2626114,      0.2947746,      0.3307985,
+                0.3713000,      0.4162091,      0.4654642,      0.5196948,      0.5795303,
+                0.6456000,      0.7184838,      0.7967133,      0.8778459,      0.9594390,
+                1.0390501,      1.1153673,      1.1884971,      1.2581233,      1.3239296,
+                1.3856000,      1.4426352,      1.4948035,      1.5421903,      1.5848807,
+                1.6229600,      1.6564048,      1.6852959,      1.7098745,      1.7303821,
+                1.7470600,      1.7600446,      1.7696233,      1.7762637,      1.7804334,
+                1.7826000,      1.7829682,      1.7816998,      1.7791982,      1.7758671,
+                1.7721100,      1.7682589,      1.7640390,      1.7589438,      1.7524663,
+                1.7441000,      1.7335595,      1.7208581,      1.7059369,      1.6887372,
+                1.6692000,      1.6475287,      1.6234127,      1.5960223,      1.5645280,
+                1.5281000,      1.4861114,      1.4395215,      1.3898799,      1.3387362,
+                1.2876400,      1.2374223,      1.1878243,      1.1387611,      1.0901480,
+                1.0419000,      0.9941976,      0.9473473,      0.9014531,      0.8566193,
+                0.8129501,      0.7705173,      0.7294448,      0.6899136,      0.6521049,
+                0.6162000,      0.5823286,      0.5504162,      0.5203376,      0.4919673,
+                0.4651800,      0.4399246,      0.4161836,      0.3938822,      0.3729459,
+                0.3533000,      0.3348578,      0.3175521,      0.3013375,      0.2861686,
+                0.2720000,      0.2588171,      0.2464838,      0.2347718,      0.2234533,
+                0.2123000,      0.2011692,      0.1901196,      0.1792254,      0.1685608,
+                0.1582000,      0.1481383,      0.1383758,      0.1289942,      0.1200751,
+                0.1117000,      0.1039048,      0.09666748,     0.08998272,     0.08384531,
+                0.07824999,     0.07320899,     0.06867816,     0.06456784,     0.06078835,
+                0.05725001,     0.05390435,     0.05074664,     0.04775276,     0.04489859,
+                0.04216000,     0.03950728,     0.03693564,     0.03445836,     0.03208872,
+                0.02984000,     0.02771181,     0.02569444,     0.02378716,     0.02198925,
+                0.02030000,     0.01871805,     0.01724036,     0.01586364,     0.01458461,
+                0.01340000,     0.01230723,     0.01130188,     0.01037792,     0.009529306,
+                0.008749999,    0.008035200,    0.007381600,    0.006785400,    0.006242800,
+                0.005749999,    0.005303600,    0.004899800,    0.004534200,    0.004202400,
+                0.003900000,    0.003623200,    0.003370600,    0.003141400,    0.002934800,
+                0.002749999,    0.002585200,    0.002438600,    0.002309400,    0.002196800,
+                0.002100000,    0.002017733,    0.001948200,    0.001889800,    0.001840933,
+                0.001800000,    0.001766267,    0.001737800,    0.001711200,    0.001683067,
+                0.001650001,    0.001610133,    0.001564400,    0.001513600,    0.001458533,
+                0.001400000,    0.001336667,    0.001270000,    0.001205000,    0.001146667,
+                0.001100000,    0.001068800,    0.001049400,    0.001035600,    0.001021200,
+                0.001000000,    0.0009686400,   0.0009299200,   0.0008868800,   0.0008425600,
+                0.0008000000,   0.0007609600,   0.0007236800,   0.0006859200,   0.0006454400,
+                0.0006000000,   0.0005478667,   0.0004916000,   0.0004354000,   0.0003834667,
+                0.0003400000,   0.0003072533,   0.0002831600,   0.0002654400,   0.0002518133,
+                0.0002400000,   0.0002295467,   0.0002206400,   0.0002119600,   0.0002021867,
+                0.0001900000,   0.0001742133,   0.0001556400,   0.0001359600,   0.0001168533,
+                0.0001000000,   0.00008613333,  0.00007460000,  0.00006500000,  0.00005693333,
+                0.00004999999,  0.00004416000,  0.00003948000,  0.00003572000,  0.00003264000,
+                0.00003000000,  0.00002765333,  0.00002556000,  0.00002364000,  0.00002181333,
+                0.00002000000,  0.00001813333,  0.00001620000,  0.00001420000,  0.00001213333,
+                0.00001000000,  0.000007733333, 0.000005400000, 0.000003200000, 0.000001333333,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000, 0.000000000000,
+                0.000000000000
+        };
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/Spectrum.java

@@ -0,0 +1,41 @@
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
+
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorXYZ;
+import eu.jonahbauer.raytracing.render.spectral.SampledSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.SampledWavelengths;
+import eu.jonahbauer.raytracing.render.texture.Color;
+import org.jetbrains.annotations.NotNull;
+
+public interface Spectrum {
+    int LAMBDA_MIN = 360;
+    int LAMBDA_MAX = 830;
+
+    /**
+     * {@return the maximum value of <code>this</code> spectrum over the range of wavelengths}
+     */
+    double max();
+
+    /**
+     * {@return the value of <code>this</code> spectrum at a given wavelength}
+     * @param lambda the wavelength in nanometers
+     */
+    double get(double lambda);
+
+    default @NotNull SampledSpectrum sample(@NotNull SampledWavelengths lambdas) {
+        return new SampledSpectrum(lambdas, this);
+    }
+
+    default @NotNull ColorXYZ toXYZ() {
+        return new ColorXYZ(
+                Util.innerProduct(Spectra.X, this) / ColorXYZ.CIE_Y_INTEGRAL,
+                Util.innerProduct(Spectra.Y, this) / ColorXYZ.CIE_Y_INTEGRAL,
+                Util.innerProduct(Spectra.Z, this) / ColorXYZ.CIE_Y_INTEGRAL
+        );
+    }
+
+    default @NotNull Color toRGB(@NotNull ColorSpace cs) {
+        return cs.toRGB(toXYZ());
+    }
+
+}

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/Util.java

@@ -0,0 +1,17 @@
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
+
+import org.jetbrains.annotations.NotNull;
+
+final class Util {
+    private Util() {
+        throw new UnsupportedOperationException();
+    }
+
+    public static double innerProduct(@NotNull Spectrum f, @NotNull Spectrum g) {
+        var integral = 0.0;
+        for (var lambda = Spectrum.LAMBDA_MIN; lambda <= Spectrum.LAMBDA_MAX; lambda++) {
+            integral += f.get(lambda) * g.get(lambda);
+        }
+        return integral;
+    }
+}

src/main/java/eu/jonahbauer/raytracing/render/texture/Color.java

@@ -5,6 +5,7 @@ import eu.jonahbauer.raytracing.math.Vec3;
 import eu.jonahbauer.raytracing.scene.SkyBox;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.Objects;
 import java.util.Random;
 
 import static eu.jonahbauer.raytracing.Main.DEBUG;
@@ -20,9 +21,9 @@ public record Color(double r, double g, double b) implements Texture, SkyBox {
         if (t < 0) return a;
         if (t > 1) return b;
         return new Color(
-                (1 - t) * a.r + t * b.r,
+                Math.fma(t, b.r, Math.fma(-t, a.r, a.r)),
-                (1 - t) * a.g + t * b.g,
+                Math.fma(t, b.g, Math.fma(-t, a.g, a.g)),
-                (1 - t) * a.b + t * b.b
+                Math.fma(t, b.b, Math.fma(-t, a.b, a.b))
         );
     }
 
@@ -86,6 +87,10 @@ public record Color(double r, double g, double b) implements Texture, SkyBox {
         this(red / 255f, green / 255f, blue / 255f);
     }
 
+    public Color(@NotNull Vec3 vec) {
+        this(vec.x(), vec.y(), vec.z());
+    }
+
     public Color {
         if (DEBUG) {
             if (!Double.isFinite(r) || !Double.isFinite(g) || !Double.isFinite(b)) {
@@ -109,6 +114,15 @@ public record Color(double r, double g, double b) implements Texture, SkyBox {
         return toInt(b);
     }
 
+    public double component(int i) {
+        return switch (i) {
+            case 0 -> r;
+            case 1 -> g;
+            case 2 -> b;
+            default -> throw new IndexOutOfBoundsException(i);
+        };
+    }
+
     @Override
     public @NotNull Color get(double u, double v, @NotNull Vec3 p) {
         return this;
@@ -124,6 +138,10 @@ public record Color(double r, double g, double b) implements Texture, SkyBox {
         return false;
     }
 
+    public @NotNull Vec3 toVec3() {
+        return new Vec3(r, g, b);
+    }
+
     private static int toInt(double value) {
         return Math.clamp((int) (255.99 * value), 0, 255);
     }

src/main/resources/eu/jonahbauer/raytracing/spectrum/CIE_std_illum_D50.csv

@@ -0,0 +1,531 @@
+300,0.01922
+301,0.222348
+302,0.425476
+303,0.628604
+304,0.831732
+305,1.03486
+306,1.23799
+307,1.44112
+308,1.64424
+309,1.84737
+310,2.0505
+311,2.62329
+312,3.19608
+313,3.76887
+314,4.34166
+315,4.91445
+316,5.48724
+317,6.06003
+318,6.63282
+319,7.20561
+320,7.7784
+321,8.47531
+322,9.17222
+323,9.86913
+324,10.566
+325,11.263
+326,11.9599
+327,12.6568
+328,13.3537
+329,14.0506
+330,14.7475
+331,15.0676
+332,15.3876
+333,15.7076
+334,16.0277
+335,16.3478
+336,16.6678
+337,16.9878
+338,17.3079
+339,17.628
+340,17.948
+341,18.2542
+342,18.5603
+343,18.8665
+344,19.1727
+345,19.4788
+346,19.785
+347,20.0912
+348,20.3974
+349,20.7035
+350,21.0097
+351,21.3029
+352,21.5961
+353,21.8894
+354,22.1826
+355,22.4758
+356,22.769
+357,23.0622
+358,23.3555
+359,23.6487
+360,23.9419
+361,24.2438
+362,24.5457
+363,24.8475
+364,25.1494
+365,25.4513
+366,25.7532
+367,26.0551
+368,26.3569
+369,26.6588
+370,26.9607
+371,26.7134
+372,26.4661
+373,26.2187
+374,25.9714
+375,25.7241
+376,25.4768
+377,25.2295
+378,24.9821
+379,24.7348
+380,24.4875
+381,25.0258
+382,25.5641
+383,26.1024
+384,26.6407
+385,27.179
+386,27.7174
+387,28.2557
+388,28.794
+389,29.3323
+390,29.8706
+391,31.8144
+392,33.7581
+393,35.7018
+394,37.6456
+395,39.5894
+396,41.5331
+397,43.4768
+398,45.4206
+399,47.3644
+400,49.3081
+401,50.0286
+402,50.749
+403,51.4695
+404,52.19
+405,52.9104
+406,53.6309
+407,54.3514
+408,55.0719
+409,55.7923
+410,56.5128
+411,56.8649
+412,57.217
+413,57.5691
+414,57.9212
+415,58.2733
+416,58.6254
+417,58.9775
+418,59.3296
+419,59.6817
+420,60.0338
+421,59.8122
+422,59.5905
+423,59.3689
+424,59.1473
+425,58.9256
+426,58.704
+427,58.4824
+428,58.2608
+429,58.0391
+430,57.8175
+431,59.5182
+432,61.219
+433,62.9197
+434,64.6205
+435,66.3212
+436,68.0219
+437,69.7227
+438,71.4234
+439,73.1242
+440,74.8249
+441,76.0671
+442,77.3094
+443,78.5516
+444,79.7938
+445,81.036
+446,82.2783
+447,83.5205
+448,84.7627
+449,86.005
+450,87.2472
+451,87.5837
+452,87.9202
+453,88.2567
+454,88.5932
+455,88.9297
+456,89.2662
+457,89.6027
+458,89.9392
+459,90.2757
+460,90.6122
+461,90.6878
+462,90.7634
+463,90.839
+464,90.9146
+465,90.9902
+466,91.0657
+467,91.1413
+468,91.2169
+469,91.2925
+470,91.3681
+471,91.7421
+472,92.1162
+473,92.4902
+474,92.8643
+475,93.2383
+476,93.6123
+477,93.9864
+478,94.3604
+479,94.7345
+480,95.1085
+481,94.7939
+482,94.4793
+483,94.1648
+484,93.8502
+485,93.5356
+486,93.221
+487,92.9064
+488,92.5919
+489,92.2773
+490,91.9627
+491,92.3388
+492,92.7149
+493,93.091
+494,93.4671
+495,93.8432
+496,94.2193
+497,94.5954
+498,94.9715
+499,95.3476
+500,95.7237
+501,95.8127
+502,95.9016
+503,95.9906
+504,96.0795
+505,96.1685
+506,96.2575
+507,96.3464
+508,96.4354
+509,96.5243
+510,96.6133
+511,96.6649
+512,96.7164
+513,96.768
+514,96.8196
+515,96.8712
+516,96.9227
+517,96.9743
+518,97.0259
+519,97.0774
+520,97.129
+521,97.626
+522,98.123
+523,98.62
+524,99.117
+525,99.614
+526,100.111
+527,100.608
+528,101.105
+529,101.602
+530,102.099
+531,101.965
+532,101.83
+533,101.696
+534,101.561
+535,101.427
+536,101.292
+537,101.158
+538,101.024
+539,100.889
+540,100.755
+541,100.911
+542,101.067
+543,101.223
+544,101.38
+545,101.536
+546,101.692
+547,101.848
+548,102.005
+549,102.161
+550,102.317
+551,102.085
+552,101.854
+553,101.622
+554,101.39
+555,101.158
+556,100.927
+557,100.695
+558,100.463
+559,100.232
+560,100
+561,99.7735
+562,99.547
+563,99.3205
+564,99.094
+565,98.8675
+566,98.641
+567,98.4145
+568,98.188
+569,97.9615
+570,97.735
+571,97.8533
+572,97.9716
+573,98.0899
+574,98.2082
+575,98.3265
+576,98.4448
+577,98.5631
+578,98.6814
+579,98.7997
+580,98.918
+581,98.3761
+582,97.8342
+583,97.2922
+584,96.7503
+585,96.2084
+586,95.6665
+587,95.1246
+588,94.5826
+589,94.0407
+590,93.4988
+591,93.9177
+592,94.3366
+593,94.7555
+594,95.1744
+595,95.5933
+596,96.0122
+597,96.4311
+598,96.85
+599,97.2689
+600,97.6878
+601,97.8459
+602,98.0041
+603,98.1622
+604,98.3203
+605,98.4784
+606,98.6366
+607,98.7947
+608,98.9528
+609,99.111
+610,99.2691
+611,99.2463
+612,99.2236
+613,99.2008
+614,99.1781
+615,99.1553
+616,99.1325
+617,99.1098
+618,99.087
+619,99.0643
+620,99.0415
+621,98.7095
+622,98.3776
+623,98.0456
+624,97.7136
+625,97.3816
+626,97.0497
+627,96.7177
+628,96.3857
+629,96.0538
+630,95.7218
+631,96.0353
+632,96.3489
+633,96.6624
+634,96.976
+635,97.2895
+636,97.603
+637,97.9166
+638,98.2301
+639,98.5437
+640,98.8572
+641,98.5382
+642,98.2192
+643,97.9002
+644,97.5812
+645,97.2622
+646,96.9432
+647,96.6242
+648,96.3052
+649,95.9862
+650,95.6672
+651,95.9195
+652,96.1717
+653,96.424
+654,96.6762
+655,96.9285
+656,97.1808
+657,97.433
+658,97.6853
+659,97.9375
+660,98.1898
+661,98.6712
+662,99.1525
+663,99.6339
+664,100.115
+665,100.597
+666,101.078
+667,101.559
+668,102.041
+669,102.522
+670,103.003
+671,102.616
+672,102.229
+673,101.842
+674,101.455
+675,101.068
+676,100.681
+677,100.294
+678,99.9071
+679,99.52
+680,99.133
+681,97.9578
+682,96.7826
+683,95.6074
+684,94.4322
+685,93.257
+686,92.0817
+687,90.9065
+688,89.7313
+689,88.5561
+690,87.3809
+691,87.8032
+692,88.2254
+693,88.6477
+694,89.0699
+695,89.4922
+696,89.9145
+697,90.3367
+698,90.759
+699,91.1812
+700,91.6035
+701,91.732
+702,91.8605
+703,91.989
+704,92.1175
+705,92.246
+706,92.3746
+707,92.5031
+708,92.6316
+709,92.7601
+710,92.8886
+711,91.2852
+712,89.6818
+713,88.0783
+714,86.4749
+715,84.8715
+716,83.2681
+717,81.6647
+718,80.0612
+719,78.4578
+720,76.8544
+721,77.8201
+722,78.7858
+723,79.7514
+724,80.7171
+725,81.6828
+726,82.6485
+727,83.6142
+728,84.5798
+729,85.5455
+730,86.5112
+731,87.1181
+732,87.7249
+733,88.3318
+734,88.9386
+735,89.5455
+736,90.1524
+737,90.7592
+738,91.3661
+739,91.9729
+740,92.5798
+741,91.1448
+742,89.7098
+743,88.2748
+744,86.8398
+745,85.4048
+746,83.9699
+747,82.5349
+748,81.0999
+749,79.6649
+750,78.2299
+751,76.1761
+752,74.1223
+753,72.0685
+754,70.0147
+755,67.9608
+756,65.907
+757,63.8532
+758,61.7994
+759,59.7456
+760,57.6918
+761,60.2149
+762,62.738
+763,65.2612
+764,67.7843
+765,70.3074
+766,72.8305
+767,75.3536
+768,77.8768
+769,80.3999
+770,82.923
+771,82.4581
+772,81.9932
+773,81.5283
+774,81.0634
+775,80.5985
+776,80.1336
+777,79.6687
+778,79.2038
+779,78.7389
+780,78.274
+781,78.402
+782,78.5301
+783,78.6581
+784,78.7862
+785,78.9142
+786,79.0422
+787,79.1703
+788,79.2983
+789,79.4264
+790,79.5544
+791,78.9391
+792,78.3238
+793,77.7085
+794,77.0932
+795,76.478
+796,75.8627
+797,75.2474
+798,74.6321
+799,74.0168
+800,73.4015
+801,72.4534
+802,71.5052
+803,70.5571
+804,69.609
+805,68.6608
+806,67.7127
+807,66.7646
+808,65.8165
+809,64.8683
+810,63.9202
+811,64.6059
+812,65.2916
+813,65.9772
+814,66.6629
+815,67.3486
+816,68.0343
+817,68.72
+818,69.4056
+819,70.0913
+820,70.777
+821,71.1435
+822,71.5099
+823,71.8764
+824,72.2429
+825,72.6094
+826,72.9758
+827,73.3423
+828,73.7088
+829,74.0752
+830,74.4417

src/main/resources/eu/jonahbauer/raytracing/spectrum/CIE_std_illum_D65.csv

@@ -0,0 +1,531 @@
+300,0.0341
+301,0.36014
+302,0.68618
+303,1.01222
+304,1.33826
+305,1.6643
+306,1.99034
+307,2.31638
+308,2.64242
+309,2.96846
+310,3.2945
+311,4.98865
+312,6.6828
+313,8.37695
+314,10.0711
+315,11.7652
+316,13.4594
+317,15.1535
+318,16.8477
+319,18.5418
+320,20.236
+321,21.9177
+322,23.5995
+323,25.2812
+324,26.963
+325,28.6447
+326,30.3265
+327,32.0082
+328,33.69
+329,35.3717
+330,37.0535
+331,37.343
+332,37.6326
+333,37.9221
+334,38.2116
+335,38.5011
+336,38.7907
+337,39.0802
+338,39.3697
+339,39.6593
+340,39.9488
+341,40.4451
+342,40.9414
+343,41.4377
+344,41.934
+345,42.4302
+346,42.9265
+347,43.4228
+348,43.9191
+349,44.4154
+350,44.9117
+351,45.0844
+352,45.257
+353,45.4297
+354,45.6023
+355,45.775
+356,45.9477
+357,46.1203
+358,46.293
+359,46.4656
+360,46.6383
+361,47.1834
+362,47.7285
+363,48.2735
+364,48.8186
+365,49.3637
+366,49.9088
+367,50.4539
+368,50.9989
+369,51.544
+370,52.0891
+371,51.8777
+372,51.6664
+373,51.455
+374,51.2437
+375,51.0323
+376,50.8209
+377,50.6096
+378,50.3982
+379,50.1869
+380,49.9755
+381,50.4428
+382,50.91
+383,51.3773
+384,51.8446
+385,52.3118
+386,52.7791
+387,53.2464
+388,53.7137
+389,54.1809
+390,54.6482
+391,57.4589
+392,60.2695
+393,63.0802
+394,65.8909
+395,68.7015
+396,71.5122
+397,74.3229
+398,77.1336
+399,79.9442
+400,82.7549
+401,83.628
+402,84.5011
+403,85.3742
+404,86.2473
+405,87.1204
+406,87.9936
+407,88.8667
+408,89.7398
+409,90.6129
+410,91.486
+411,91.6806
+412,91.8752
+413,92.0697
+414,92.2643
+415,92.4589
+416,92.6535
+417,92.8481
+418,93.0426
+419,93.2372
+420,93.4318
+421,92.7568
+422,92.0819
+423,91.4069
+424,90.732
+425,90.057
+426,89.3821
+427,88.7071
+428,88.0322
+429,87.3572
+430,86.6823
+431,88.5006
+432,90.3188
+433,92.1371
+434,93.9554
+435,95.7736
+436,97.5919
+437,99.4102
+438,101.228
+439,103.047
+440,104.865
+441,106.079
+442,107.294
+443,108.508
+444,109.722
+445,110.936
+446,112.151
+447,113.365
+448,114.579
+449,115.794
+450,117.008
+451,117.088
+452,117.169
+453,117.249
+454,117.33
+455,117.41
+456,117.49
+457,117.571
+458,117.651
+459,117.732
+460,117.812
+461,117.517
+462,117.222
+463,116.927
+464,116.632
+465,116.336
+466,116.041
+467,115.746
+468,115.451
+469,115.156
+470,114.861
+471,114.967
+472,115.073
+473,115.18
+474,115.286
+475,115.392
+476,115.498
+477,115.604
+478,115.711
+479,115.817
+480,115.923
+481,115.212
+482,114.501
+483,113.789
+484,113.078
+485,112.367
+486,111.656
+487,110.945
+488,110.233
+489,109.522
+490,108.811
+491,108.865
+492,108.92
+493,108.974
+494,109.028
+495,109.082
+496,109.137
+497,109.191
+498,109.245
+499,109.3
+500,109.354
+501,109.199
+502,109.044
+503,108.888
+504,108.733
+505,108.578
+506,108.423
+507,108.268
+508,108.112
+509,107.957
+510,107.802
+511,107.501
+512,107.2
+513,106.898
+514,106.597
+515,106.296
+516,105.995
+517,105.694
+518,105.392
+519,105.091
+520,104.79
+521,105.08
+522,105.37
+523,105.66
+524,105.95
+525,106.239
+526,106.529
+527,106.819
+528,107.109
+529,107.399
+530,107.689
+531,107.361
+532,107.032
+533,106.704
+534,106.375
+535,106.047
+536,105.719
+537,105.39
+538,105.062
+539,104.733
+540,104.405
+541,104.369
+542,104.333
+543,104.297
+544,104.261
+545,104.225
+546,104.19
+547,104.154
+548,104.118
+549,104.082
+550,104.046
+551,103.641
+552,103.237
+553,102.832
+554,102.428
+555,102.023
+556,101.618
+557,101.214
+558,100.809
+559,100.405
+560,100
+561,99.6334
+562,99.2668
+563,98.9003
+564,98.5337
+565,98.1671
+566,97.8005
+567,97.4339
+568,97.0674
+569,96.7008
+570,96.3342
+571,96.2796
+572,96.225
+573,96.1703
+574,96.1157
+575,96.0611
+576,96.0065
+577,95.9519
+578,95.8972
+579,95.8426
+580,95.788
+581,95.0778
+582,94.3675
+583,93.6573
+584,92.947
+585,92.2368
+586,91.5266
+587,90.8163
+588,90.1061
+589,89.3958
+590,88.6856
+591,88.8177
+592,88.9497
+593,89.0818
+594,89.2138
+595,89.3459
+596,89.478
+597,89.61
+598,89.7421
+599,89.8741
+600,90.0062
+601,89.9655
+602,89.9248
+603,89.8841
+604,89.8434
+605,89.8026
+606,89.7619
+607,89.7212
+608,89.6805
+609,89.6398
+610,89.5991
+611,89.4091
+612,89.219
+613,89.029
+614,88.8389
+615,88.6489
+616,88.4589
+617,88.2688
+618,88.0788
+619,87.8887
+620,87.6987
+621,87.2577
+622,86.8167
+623,86.3757
+624,85.9347
+625,85.4936
+626,85.0526
+627,84.6116
+628,84.1706
+629,83.7296
+630,83.2886
+631,83.3297
+632,83.3707
+633,83.4118
+634,83.4528
+635,83.4939
+636,83.535
+637,83.576
+638,83.6171
+639,83.6581
+640,83.6992
+641,83.332
+642,82.9647
+643,82.5975
+644,82.2302
+645,81.863
+646,81.4958
+647,81.1285
+648,80.7613
+649,80.394
+650,80.0268
+651,80.0456
+652,80.0644
+653,80.0831
+654,80.1019
+655,80.1207
+656,80.1395
+657,80.1583
+658,80.177
+659,80.1958
+660,80.2146
+661,80.4209
+662,80.6272
+663,80.8336
+664,81.0399
+665,81.2462
+666,81.4525
+667,81.6588
+668,81.8652
+669,82.0715
+670,82.2778
+671,81.8784
+672,81.4791
+673,81.0797
+674,80.6804
+675,80.281
+676,79.8816
+677,79.4823
+678,79.0829
+679,78.6836
+680,78.2842
+681,77.4279
+682,76.5716
+683,75.7153
+684,74.859
+685,74.0027
+686,73.1465
+687,72.2902
+688,71.4339
+689,70.5776
+690,69.7213
+691,69.9101
+692,70.0989
+693,70.2876
+694,70.4764
+695,70.6652
+696,70.854
+697,71.0428
+698,71.2315
+699,71.4203
+700,71.6091
+701,71.8831
+702,72.1571
+703,72.4311
+704,72.7051
+705,72.979
+706,73.253
+707,73.527
+708,73.801
+709,74.075
+710,74.349
+711,73.0745
+712,71.8
+713,70.5255
+714,69.251
+715,67.9765
+716,66.702
+717,65.4275
+718,64.153
+719,62.8785
+720,61.604
+721,62.4322
+722,63.2603
+723,64.0885
+724,64.9166
+725,65.7448
+726,66.573
+727,67.4011
+728,68.2293
+729,69.0574
+730,69.8856
+731,70.4057
+732,70.9259
+733,71.446
+734,71.9662
+735,72.4863
+736,73.0064
+737,73.5266
+738,74.0467
+739,74.5669
+740,75.087
+741,73.9376
+742,72.7881
+743,71.6387
+744,70.4893
+745,69.3398
+746,68.1904
+747,67.041
+748,65.8916
+749,64.7421
+750,63.5927
+751,61.8752
+752,60.1578
+753,58.4403
+754,56.7229
+755,55.0054
+756,53.288
+757,51.5705
+758,49.8531
+759,48.1356
+760,46.4182
+761,48.4569
+762,50.4956
+763,52.5344
+764,54.5731
+765,56.6118
+766,58.6505
+767,60.6892
+768,62.728
+769,64.7667
+770,66.8054
+771,66.4631
+772,66.1209
+773,65.7786
+774,65.4364
+775,65.0941
+776,64.7518
+777,64.4096
+778,64.0673
+779,63.7251
+780,63.3828
+781,63.4749
+782,63.567
+783,63.6592
+784,63.7513
+785,63.8434
+786,63.9355
+787,64.0276
+788,64.1198
+789,64.2119
+790,64.304
+791,63.8188
+792,63.3336
+793,62.8484
+794,62.3632
+795,61.8779
+796,61.3927
+797,60.9075
+798,60.4223
+799,59.9371
+800,59.4519
+801,58.7026
+802,57.9533
+803,57.204
+804,56.4547
+805,55.7054
+806,54.9562
+807,54.2069
+808,53.4576
+809,52.7083
+810,51.959
+811,52.5072
+812,53.0553
+813,53.6035
+814,54.1516
+815,54.6998
+816,55.248
+817,55.7961
+818,56.3443
+819,56.8924
+820,57.4406
+821,57.7278
+822,58.015
+823,58.3022
+824,58.5894
+825,58.8765
+826,59.1637
+827,59.4509
+828,59.7381
+829,60.0253
+830,60.3125