diff --git a/orx-kinect-common/src/main/kotlin/Kinect.kt b/orx-kinect-common/src/main/kotlin/Kinect.kt index 22e0073a..736686fe 100644 --- a/orx-kinect-common/src/main/kotlin/Kinect.kt +++ b/orx-kinect-common/src/main/kotlin/Kinect.kt @@ -2,6 +2,7 @@ package org.openrndr.extra.kinect import org.openrndr.Extension import org.openrndr.draw.* +import org.openrndr.resourceUrl import java.lang.RuntimeException /** @@ -10,11 +11,13 @@ import java.lang.RuntimeException * @param data needed to make low level kinect support calls. */ interface Kinects { + fun countDevices(): Int /** * Starts kinect device of a given number. * + * @param num the kinect device index. * @throws KinectException if device of such a number does not exist, * better to count them first. * @see countDevices @@ -24,7 +27,8 @@ interface Kinects { /** * Executes low level Kinect commands in the kinect thread. */ - fun execute(commands: (CTX) -> Any) : Any + fun execute(commands: (CTX) -> T) : T + } /** @@ -38,7 +42,7 @@ interface KinectDevice : Extension { /** * Executes low level Kinect commands in the kinect thread in the context of this device. */ - fun execute(commands: (CTX) -> Any): Any + fun execute(commands: (CTX) -> T): T } interface KinectCamera { @@ -55,3 +59,31 @@ interface KinectDepthCamera : KinectCamera { } class KinectException(msg: String) : RuntimeException(msg) + +/** + * Maps depth values to grayscale. + */ +class DepthToGrayscaleMapper : Filter( + filterShaderFromUrl(resourceUrl("depth-to-grayscale.frag", Kinects::class.java)) +) + +/** + * Maps depth values to color map according to natural light dispersion as described + * by Alan Zucconi in the + * Improving the Rainbow + * article. + */ +class DepthToColorsZucconi6Mapper : Filter( + filterShaderFromUrl(resourceUrl("depth-to-colors-zucconi6.frag", Kinects::class.java)) +) + +/** + * Maps depth values to color map according to + * + * Turbo, An Improved Rainbow Colormap for Visualization + * + * by Google. + */ +class DepthToColorsTurboMapper : Filter( + filterShaderFromUrl(resourceUrl("depth-to-colors-turbo.frag", Kinects::class.java)) +) diff --git a/orx-kinect-common/src/main/resources/org/openrndr/extra/kinect/depth-to-colors-turbo.frag b/orx-kinect-common/src/main/resources/org/openrndr/extra/kinect/depth-to-colors-turbo.frag new file mode 100644 index 00000000..307736a1 --- /dev/null +++ b/orx-kinect-common/src/main/resources/org/openrndr/extra/kinect/depth-to-colors-turbo.frag @@ -0,0 +1,41 @@ +#version 330 + +uniform sampler2D tex0; +out vec3 color; + +float saturate(in float x) { + return max(0, min(1, x)); +} + +// 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) + +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() { + float depth = texelFetch(tex0, ivec2(int(gl_FragCoord.x), int(gl_FragCoord.y)), 0).r; + color = (depth >= .999) ? vec3(0) : TurboColormap(depth); +} diff --git a/orx-kinect-common/src/main/resources/org/openrndr/extra/kinect/depth-to-colors-zucconi6.frag b/orx-kinect-common/src/main/resources/org/openrndr/extra/kinect/depth-to-colors-zucconi6.frag new file mode 100644 index 00000000..882e6c0c --- /dev/null +++ b/orx-kinect-common/src/main/resources/org/openrndr/extra/kinect/depth-to-colors-zucconi6.frag @@ -0,0 +1,68 @@ +#version 330 + +uniform sampler2D tex0; // kinect raw +out vec3 color; + +// 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 + + + +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() { + float depth = texelFetch(tex0, ivec2(int(gl_FragCoord.x), int(gl_FragCoord.y)), 0).r; + color = (depth >= .999) ? vec3(0) : spectral_zucconi6(depth); +} diff --git a/orx-kinect-common/src/main/resources/org/openrndr/extra/kinect/depth-to-grayscale.frag b/orx-kinect-common/src/main/resources/org/openrndr/extra/kinect/depth-to-grayscale.frag new file mode 100644 index 00000000..24e40387 --- /dev/null +++ b/orx-kinect-common/src/main/resources/org/openrndr/extra/kinect/depth-to-grayscale.frag @@ -0,0 +1,9 @@ +#version 330 + +uniform sampler2D tex0; +out vec3 color; + +void main() { + float depth = texelFetch(tex0, ivec2(int(gl_FragCoord.x), int(gl_FragCoord.y)), 0).r; + color = (depth >= .999) ? vec3(0) : vec3(depth); +}