add filter sketches

Author: monkstone

processing_app/topics/filters/image_filtering/Rakefile

@@ -0,0 +1,30 @@
+# Simple demo Rakefile to autorun samples in current directory
+# adjust path to rp5 executable, and or opts as required
+
+SAMPLES_DIR="./"
+
+desc 'run demo'
+task :default => [:demo]
+
+desc 'demo'
+task :demo do
+  samples_list.shuffle.each{|sample| run_sample sample}
+end
+
+def samples_list
+  files = []
+  Dir.chdir(SAMPLES_DIR)
+  Dir.glob("*.rb").each do |file|
+    files << File.join(SAMPLES_DIR, file)
+  end
+  return files
+end
+
+def run_sample(sample_name)
+  puts "Running #{sample_name}...quit to run next sample"
+  open("|jruby #{sample_name}", "r") do |io|
+    while l = io.gets
+      puts(l.chop)
+    end
+  end
+end

processing_app/topics/filters/image_filtering/bicubic.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env jruby
+require 'propane'
+# Bicubic filtering (see bicubic.glsl file for details)
+# Uncheck 'apply_filter' to show regular texture map filtering
+# Ported to propane by Martin Prout
+class BicubicFilter < Propane::App
+  load_library :control_panel
+
+  attr_reader :bicubic, :my_image, :hide, :panel, :zoom
+
+  def settings
+    size(512, 512, P2D)
+  end
+
+  def setup
+    sketch_title 'Bicubic Filtering'
+    control_panel do |c|
+      c.look_feel 'Nimbus'
+      c.title = 'zoom / bicubic'
+      c.slider    :zoom, 0.0..100, 60.0
+      c.checkbox  :apply_filter, true
+      @panel = c
+    end
+    @hide = false
+    @my_image  = load_image(data_path('texture.jpg'))
+    @bicubic = load_shader(data_path('bicubic.glsl'))
+    bicubic.set('sketchSize', width.to_f, height.to_f)
+  end
+
+  def draw
+    unless hide
+      @hide = true
+      panel.set_visible(hide)
+    end
+    background(0)
+    # Draw the image on the scene
+    image(my_image, 0, 0)
+    mode = @apply_filter ? 1 : 0
+    bicubic.set('mode', mode)
+    level = map1d(zoom, (0..100), (0.5..0.1))
+    bicubic.set('zoomLevel', level)
+    # Applies the shader to everything that has already been drawn
+    filter(bicubic)
+  end
+
+  def mouse_pressed
+    @hide = false if hide
+  end
+end
+
+BicubicFilter.new

processing_app/topics/filters/image_filtering/bilateral.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env jruby
+require 'propane'
+# Bilateral smoothing
+# Original shader by mrharicot
+# https://www.shadertoy.com/view/4dfGDH
+# Ported to Processing by Raphaël de Courville <twitter: @sableRaph>
+# Ported to propane by Martin Prout
+# Keep mouse pressed to show unfiltered image
+class BilateralFilter < Propane::App
+  attr_reader :apply, :bilateral, :my_image
+
+  def settings
+    size(512, 512, P2D)
+  end
+
+  def setup
+    sketch_title 'Bilateral Filtering'
+    @my_image  = load_image(data_path('texture.jpg'))
+    @bilateral = load_shader(data_path('bilateral.glsl'))
+    bilateral.set('sketchSize', width.to_f, height.to_f)
+  end
+
+  def draw
+    background(0)
+    # Draw the image on the scene
+    image(my_image, 0, 0)
+    # Applies the shader to everything that has already been drawn
+    return if mouse_pressed?
+    filter(bilateral)
+  end
+end
+
+BilateralFilter.new

processing_app/topics/filters/image_filtering/contrast_sat_bright.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env jruby
+require 'propane'
+class ContrastSatBright < Propane::App
+  load_library :control_panel
+
+  attr_reader :my_filter, :my_image, :panel, :hide,
+  :brightness, :contrast, :saturation
+
+  def settings
+    size(512, 512, P2D)
+  end
+
+  def setup
+    sketch_title 'Contrast Saturation Brightness'
+    control_panel do |c|
+      c.look_feel 'Nimbus'
+      c.title = 'Control'
+      c.slider  :brightness, 0..100, 60
+      c.slider  :saturation,  0..100, 70
+      c.slider  :contrast,  50..150, 100
+      @panel = c
+    end
+    @hide = false
+    @my_image  = load_image(data_path('texture.jpg'))
+    @my_filter = load_shader(data_path('shader.glsl'))
+  end
+
+  def draw
+    unless hide
+      @hide = true
+      panel.set_visible(hide)
+    end
+    background(0)
+    # Draw the image on the scene
+    image(my_image, 0, 0)
+    # contrast settings: 1.0 = 100% 0.5 = 50% 1.5 = 150%
+    c = map1d(contrast, (50..150), (0.5..1.5))
+    s = map1d(saturation, (0..100), (0.0..1.5))
+    b = map1d(brightness, (0..100), (0.3..1.5))
+    # Pass the parameters to the shader
+    my_filter.set('contrast', c)
+    my_filter.set('saturation', s)
+    my_filter.set('brightness', b)
+    # Applies the shader to everything that has already been drawn
+    filter(my_filter)
+  end
+end
+
+ContrastSatBright.new

processing_app/topics/filters/image_filtering/data/bicubic.glsl

@@ -0,0 +1,138 @@
+// Created by inigo quilez - iq/2013
+// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
+//
+// This is the implementation for my article "improved texture interpolation"
+// 
+// http://www.iquilezles.org/www/articles/texture/texture.htm
+//
+// It shows how to get some smooth texture interpolation without resorting to the regular
+// bicubic filtering, which is pretty expensive because it needs 9 texels instead of the 
+// 4 the hardware uses for bilinear interpolation.
+//
+// With this techinique here, you van get smooth interpolation while the hardware still 
+// uses only 4 texels, by tricking the hardware. The idea is to get the fractional part
+// of the texel coordinates and apply a smooth curve to it such that the derivatives are
+// zero at the extremes. The regular cubic or quintic smoothstep functions are just
+// perfect for this task.
+
+// Modified to do bicubic filtering, sgreen/2013
+
+// Adapted for Processing by Raphaël de Courville <@sableRaph>
+
+uniform sampler2D texture;
+
+uniform vec2 sketchSize;
+
+uniform float zoomLevel;
+
+uniform int mode;
+
+vec4 texture2D_smooth(sampler2D tex, vec2 uv, vec2 res)
+{
+	uv = uv*res + 0.5;
+	vec2 iuv = floor( uv );
+	vec2 fuv = fract( uv );
+	uv = iuv + fuv*fuv*(3.0-2.0*fuv); // fuv*fuv*fuv*(fuv*(fuv*6.0-15.0)+10.0);;
+	uv = (uv - 0.5)/res;
+	return texture2D( texture, uv );
+}
+
+// 4x4 bicubic filter using 4 bilinear texture lookups 
+// See GPU Gems 2: "Fast Third-Order Texture Filtering", Sigg & Hadwiger:
+// http://http.developer.nvidia.com/GPUGems2/gpugems2_chapter20.html
+
+// w0, w1, w2, and w3 are the four cubic B-spline basis functions
+float w0(float a)
+{
+    return (1.0/6.0)*(a*(a*(-a + 3.0) - 3.0) + 1.0);
+}
+
+float w1(float a)
+{
+    return (1.0/6.0)*(a*a*(3.0*a - 6.0) + 4.0);
+}
+
+float w2(float a)
+{
+    return (1.0/6.0)*(a*(a*(-3.0*a + 3.0) + 3.0) + 1.0);
+}
+
+float w3(float a)
+{
+    return (1.0/6.0)*(a*a*a);
+}
+
+// g0 and g1 are the two amplitude functions
+float g0(float a)
+{
+    return w0(a) + w1(a);
+}
+
+float g1(float a)
+{
+    return w2(a) + w3(a);
+}
+
+// h0 and h1 are the two offset functions
+float h0(float a)
+{
+    return -1.0 + w1(a) / (w0(a) + w1(a));
+}
+
+float h1(float a)
+{
+    return 1.0 + w3(a) / (w2(a) + w3(a));
+}
+
+vec4 texture2D_bicubic(sampler2D tex, vec2 uv, vec2 res)
+{
+	uv = uv*res + 0.5;
+	vec2 iuv = floor( uv );
+	vec2 fuv = fract( uv );
+
+    float g0x = g0(fuv.x);
+    float g1x = g1(fuv.x);
+    float h0x = h0(fuv.x);
+    float h1x = h1(fuv.x);
+    float h0y = h0(fuv.y);
+    float h1y = h1(fuv.y);
+
+	vec2 p0 = (vec2(iuv.x + h0x, iuv.y + h0y) - 0.5) / res;
+	vec2 p1 = (vec2(iuv.x + h1x, iuv.y + h0y) - 0.5) / res;
+	vec2 p2 = (vec2(iuv.x + h0x, iuv.y + h1y) - 0.5) / res;
+	vec2 p3 = (vec2(iuv.x + h1x, iuv.y + h1y) - 0.5) / res;
+	
+    return g0(fuv.y) * (g0x * texture2D(tex, p0)  +
+                        g1x * texture2D(tex, p1)) +
+           g1(fuv.y) * (g0x * texture2D(tex, p2)  +
+                        g1x * texture2D(tex, p3));
+}
+
+
+void main(void)
+{
+    vec2 p = gl_FragCoord.xy / sketchSize.xy;
+    vec2 uv = p * zoomLevel;	
+
+	float textureResolution = 512.0;
+	
+	vec3 col;
+
+    //---------------------------------------------	
+	// regular texture map filtering
+    //---------------------------------------------	
+	//vec3 colA = texture2D( texture, uv ).xyz;
+	if( mode == 0 ) {
+		col = texture2D_smooth( texture, uv, vec2(textureResolution) ).xyz;
+	}
+
+    //---------------------------------------------	
+	// my own filtering 
+    //---------------------------------------------	
+	//vec3 colB = texture2D_smooth( texture, uv, vec2(textureResolution) ).xyz;
+	else {
+		col = texture2D_bicubic( texture, uv, vec2(textureResolution) ).xyz;	
+	}
+
+    gl_FragColor = vec4( col, 1.0 );
+}

processing_app/topics/filters/image_filtering/data/bilateral.glsl

@@ -0,0 +1,67 @@
+
+// Original shader by mrharicot
+// https://www.shadertoy.com/view/4dfGDH
+
+// Ported to Processing by Raphaël de Courville <twitter: @sableRaph>
+
+
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+#define SIGMA 10.0
+#define BSIGMA 0.1
+#define MSIZE 20
+
+uniform sampler2D texture;
+
+uniform vec2 sketchSize;
+
+float normpdf(in float x, in float sigma)
+{
+	return 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;
+}
+
+float normpdf3(in vec3 v, in float sigma)
+{
+	return 0.39894*exp(-0.5*dot(v,v)/(sigma*sigma))/sigma;
+}
+
+
+void main(void)
+{
+	vec3 c = texture2D( texture, vec2(0.0, 0.0) + (gl_FragCoord.xy / sketchSize.xy) ).rgb;
+		
+	//declare stuff
+	const int kSize = (MSIZE-1)/2;
+	float kernel[MSIZE];
+	vec3 final_colour = vec3(0.0);
+	
+	//create the 1-D kernel
+	float Z = 0.0;
+	for (int j = 0; j <= kSize; ++j)
+	{
+		kernel[kSize+j] = kernel[kSize-j] = normpdf(float(j), SIGMA);
+	}
+	
+	
+	vec3 cc;
+	float factor;
+	float bZ = 1.0/normpdf(0.0, BSIGMA);
+	//read out the texels
+	for (int i=-kSize; i <= kSize; ++i)
+	{
+		for (int j=-kSize; j <= kSize; ++j)
+		{
+			cc = texture2D(texture, vec2(0.0, 0.0) + ( gl_FragCoord.xy + vec2(float(i),float(j)) ) / sketchSize.xy ).rgb;
+			factor = normpdf3(cc-c, BSIGMA)*bZ*kernel[kSize+j]*kernel[kSize+i];
+			Z += factor;
+			final_colour += factor*cc;
+
+		}
+	}
+	
+	gl_FragColor = vec4(final_colour/Z, 1.0);
+
+}