orx-kinect refactoring + new general orx-depth-camera (#257)

orx-fx/README.md

@@ -167,6 +167,25 @@ fun main() = application {
 }
 ```
 
+### Colormap
+
+Colormap filters operate only on the RED color channel. For example
+depth maps from
+[orx-depth-camera](https://github.com/openrndr/orx/tree/master/orx-depth-camera).
+
+They allow selection of `min` / `max` value range and applying exponential
+shaping `curve` within this range:
+
+- `GrayscaleColormap` - maps to gray tones
+- `SpectralZucconiColormap` - maps to natural light dispersion spectrum as described
+  by Alan Zucconi in the
+  [Improving the Rainbow](https://www.alanzucconi.com/2017/07/15/improving-the-rainbow/)
+  article.
+- `TurboColormap` - maps to Turbo Colormap according to
+  [Turbo, An Improved Rainbow Colormap for Visualization](https://ai.googleblog.com/2019/08/turbo-improved-rainbow-colormap-for.html)
+  by Google.
+
+
 
 <!-- __demos__ >
 # Demos

orx-fx/src/commonMain/kotlin/colormap/ColormapFilter.kt

@@ -0,0 +1,24 @@
+package org.openrndr.extra.fx.colormap
+
+import org.openrndr.draw.Filter
+import org.openrndr.extra.fx.mppFilterShader
+import org.openrndr.extra.parameters.DoubleParameter
+
+abstract class ColormapFilter(code: String, name: String) : Filter(mppFilterShader(code, name)) {
+
+    @DoubleParameter(label = "min value", low = 0.0, high = 1.0, order = 0)
+    var minValue: Double by parameters
+
+    @DoubleParameter(label = "max value", low = 0.0, high = 1.0, order = 1)
+    var maxValue: Double by parameters
+
+    @DoubleParameter(label = "curve", low = 0.001, high = 10.0, order = 2)
+    var curve: Double by parameters
+
+    init {
+        minValue = 0.0
+        maxValue = 1.0
+        curve = 1.0
+    }
+
+}

orx-fx/src/commonMain/kotlin/colormap/GrayscaleColormap.kt

@@ -0,0 +1,10 @@
+package org.openrndr.extra.fx.colormap
+
+import org.openrndr.extra.fx.fx_grayscale_colormap
+import org.openrndr.extra.parameters.Description
+
+/**
+ * Maps values of the RED color channel to grayscale.
+ */
+@Description("grayscale colormap")
+class GrayscaleColormap : ColormapFilter(fx_grayscale_colormap, "grayscale-colormap")

orx-fx/src/commonMain/kotlin/colormap/SpectralZucconiColormap.kt

@@ -0,0 +1,13 @@
+package org.openrndr.extra.fx.colormap
+
+import org.openrndr.extra.fx.fx_spectral_zucconi_colormap
+import org.openrndr.extra.parameters.Description
+
+/**
+ * Maps values of the RED color channel to natural light dispersion spectrum as described
+ * by Alan Zucconi in the
+ * [Improving the Rainbow](https://www.alanzucconi.com/2017/07/15/improving-the-rainbow/)
+ * article.
+ */
+@Description("spectral colormap")
+class SpectralZucconiColormap : ColormapFilter(fx_spectral_zucconi_colormap, "spectral-zucconi-colormap")

orx-fx/src/commonMain/kotlin/colormap/TurboColormap.kt

@@ -0,0 +1,12 @@
+package org.openrndr.extra.fx.colormap
+
+import org.openrndr.extra.fx.fx_turbo_colormap
+import org.openrndr.extra.parameters.Description
+
+/**
+ * Maps values of the RED color channel to Turbo Colormap according to
+ * [Turbo, An Improved Rainbow Colormap for Visualization](https://ai.googleblog.com/2019/08/turbo-improved-rainbow-colormap-for.html)
+ * by Google.
+ */
+@Description("turbo colormap")
+open class TurboColormap : ColormapFilter(fx_turbo_colormap, "turbo-colormap")

orx-fx/src/shaders/glsl/colormap/grayscale-colormap.frag

@@ -0,0 +1,31 @@
+#ifdef OR_IN_OUT
+in vec2 v_texCoord0;
+#else
+varying vec2 v_texCoord0;
+#endif
+
+uniform sampler2D   tex0;
+uniform float       minValue;
+uniform float       maxValue;
+uniform float       curve;
+
+#ifndef OR_GL_FRAGCOLOR
+out vec4 o_color;
+#endif
+
+void main() {
+    #ifndef OR_GL_TEXTURE2D
+    float red = texture(tex0, v_texCoord0).r;
+    #else
+    float red = texture2D(tex0, v_texCoord0).r;
+    #endif
+    float value = (red - minValue) / (maxValue - minValue);
+    vec3 color = vec3(pow(value, curve));
+    color *= step(value, 1.) * step(0., value);
+    vec4 result = vec4(color, 1.);
+    #ifdef OR_GL_FRAGCOLOR
+    gl_FragColor = result;
+    #else
+    o_color = result;
+    #endif
+}

orx-fx/src/shaders/glsl/colormap/spectral-zucconi-colormap.frag

@@ -0,0 +1,88 @@
+// Spectral Colour Schemes
+// By Alan Zucconi
+// Website: www.alanzucconi.com
+// Twitter: @AlanZucconi
+
+// Example of different spectral colour schemes
+// to convert visible wavelengths of light (400-700 nm) to RGB colours.
+
+// The function "spectral_zucconi6" provides the best approximation
+// without including any branching.
+// Its faster version, "spectral_zucconi", is advised for mobile applications.
+
+
+// Read "Improving the Rainbow" for more information
+// http://www.alanzucconi.com/?p=6703
+
+#ifdef OR_IN_OUT
+in vec2 v_texCoord0;
+#else
+varying vec2 v_texCoord0;
+#endif
+
+uniform sampler2D tex0;             // kinect raw
+uniform float     minValue;
+uniform float     maxValue;
+uniform float     curve;
+
+#ifndef OR_GL_FRAGCOLOR
+out vec4 o_color;
+#endif
+
+float saturate (float x)
+{
+    return min(1.0, max(0.0,x));
+}
+vec3 saturate (vec3 x)
+{
+    return min(vec3(1.,1.,1.), max(vec3(0.,0.,0.),x));
+}
+
+// --- Spectral Zucconi --------------------------------------------
+// By Alan Zucconi
+// Based on GPU Gems: https://developer.nvidia.com/sites/all/modules/custom/gpugems/books/GPUGems/gpugems_ch08.html
+// But with values optimised to match as close as possible the visible spectrum
+// Fits this: https://commons.wikimedia.org/wiki/File:Linear_visible_spectrum.svg
+// With weighter MSE (RGB weights: 0.3, 0.59, 0.11)
+vec3 bump3y (vec3 x, vec3 yoffset)
+{
+    vec3 y = vec3(1.,1.,1.) - x * x;
+    y = saturate(y-yoffset);
+    return y;
+}
+
+// --- Spectral Zucconi 6 --------------------------------------------
+
+// Based on GPU Gems
+// Optimised by Alan Zucconi
+vec3 spectral_zucconi6 (float x)
+{
+    const vec3 c1 = vec3(3.54585104, 2.93225262, 2.41593945);
+    const vec3 x1 = vec3(0.69549072, 0.49228336, 0.27699880);
+    const vec3 y1 = vec3(0.02312639, 0.15225084, 0.52607955);
+
+    const vec3 c2 = vec3(3.90307140, 3.21182957, 3.96587128);
+    const vec3 x2 = vec3(0.11748627, 0.86755042, 0.66077860);
+    const vec3 y2 = vec3(0.84897130, 0.88445281, 0.73949448);
+
+    return
+        bump3y(c1 * (x - x1), y1) +
+        bump3y(c2 * (x - x2), y2);
+}
+
+void main() {
+    #ifndef OR_GL_TEXTURE2D
+    float red = texture(tex0, v_texCoord0).r;
+    #else
+    float red = texture2D(tex0, v_texCoord0).r;
+    #endif
+    float value = (red - minValue) / (maxValue - minValue);
+    vec3 color = spectral_zucconi6(pow(value, curve));
+    color *= step(value, 1.) * step(0., value);
+    vec4 result = vec4(color, 1.);
+    #ifdef OR_GL_FRAGCOLOR
+    gl_FragColor = result;
+    #else
+    o_color = result;
+    #endif
+}

orx-fx/src/shaders/glsl/colormap/turbo-colormap.frag

@@ -0,0 +1,64 @@
+// TurboColormap
+// Copyright 2019 Google LLC.
+// SPDX-License-Identifier: Apache-2.0
+
+// Polynomial approximation in GLSL for the Turbo colormap
+// Original LUT: https://gist.github.com/mikhailov-work/ee72ba4191942acecc03fe6da94fc73f
+
+// Authors:
+//   Colormap Design: Anton Mikhailov (mikhailov@google.com)
+//   GLSL Approximation: Ruofei Du (ruofei@google.com)
+
+#ifdef OR_IN_OUT
+in vec2 v_texCoord0;
+#else
+varying vec2 v_texCoord0;
+#endif
+
+uniform sampler2D tex0;
+uniform float     minValue;
+uniform float     maxValue;
+uniform float     curve;
+
+#ifndef OR_GL_FRAGCOLOR
+out vec4 o_color;
+#endif
+
+float saturate(in float x) {
+    return max(0, min(1, x));
+}
+
+vec3 TurboColormap(in float x) {
+    const vec4 kRedVec4 = vec4(0.13572138, 4.61539260, -42.66032258, 132.13108234);
+    const vec4 kGreenVec4 = vec4(0.09140261, 2.19418839, 4.84296658, -14.18503333);
+    const vec4 kBlueVec4 = vec4(0.10667330, 12.64194608, -60.58204836, 110.36276771);
+    const vec2 kRedVec2 = vec2(-152.94239396, 59.28637943);
+    const vec2 kGreenVec2 = vec2(4.27729857, 2.82956604);
+    const vec2 kBlueVec2 = vec2(-89.90310912, 27.34824973);
+
+    x = saturate(x);
+    vec4 v4 = vec4( 1.0, x, x * x, x * x * x);
+    vec2 v2 = v4.zw * v4.z;
+    return vec3(
+        dot(v4, kRedVec4)   + dot(v2, kRedVec2),
+        dot(v4, kGreenVec4) + dot(v2, kGreenVec2),
+        dot(v4, kBlueVec4)  + dot(v2, kBlueVec2)
+    );
+}
+
+void main() {
+    #ifndef OR_GL_TEXTURE2D
+    float red = texture(tex0, v_texCoord0).r;
+    #else
+    float red = texture2D(tex0, v_texCoord0).r;
+    #endif
+    float value = (red - minValue) / (maxValue - minValue);
+    vec3 color = TurboColormap(pow(value, curve));
+    color *= step(value, 1.) * step(0., value);
+    vec4 result = vec4(color, 1.);
+    #ifdef OR_GL_FRAGCOLOR
+    gl_FragColor = result;
+    #else
+    o_color = result;
+    #endif
+}