fix-ups

Author: monkstone

library/video/capture/capture_test.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env jruby
+require 'picrate'
+
+# Use this sketch to find available cameras you should set size to match
+# your web camera eg 720P camera is 960, 720. Not tested with the
+# RaspberryPI Camera module
+class CaptureTest < Processing::App
+
+  load_library :video # install latest beta version
+  java_import 'processing.video.Capture'
+
+  attr_reader :cam, :cameras
+
+  def setup
+    sketch_title 'Capture Test'
+    @cameras = Capture.list
+    fail 'There are no matching cameras.' if cameras.length.zero?
+    start_capture(cameras[0])
+    font = create_font('DejaVu Sans', 28)
+    text_font font, 28
+  end
+
+  def start_capture(cam_string)
+    # NB: camera should be initialised as follows
+    @cam = Capture.new(self, width, height, cam_string)
+    p format('Using camera %s', cam_string)
+    cam.start
+  end
+
+  def draw
+    return unless cam.available # ruby guard clause
+    
+    cam.read
+    set(0, 0, cam)
+    fill 255
+    rect 0, height - 80, width, 50
+    fill 0
+    text cameras[0], 30, height - 50
+  end
+
+  def settings
+    size 960, 720, P2D
+  end
+end
+
+CaptureTest.new

library/video/capture/data/droste.glsl

@@ -0,0 +1,68 @@
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+// This implementation is based on GLSL code by ArKano22:
+// http://www.gamedev.net/topic/590070-glsl-droste/
+#define PROCESSING_TEXTURE_SHADER
+uniform sampler2D texture; // iChannel0 in Shadertoy
+uniform float globalTime;
+uniform vec2 sketchSize; // iResolution in Shadertoy
+uniform int mode;
+
+const float TWO_PI = 3.141592*2.0;
+//ADJUSTABLE PARAMETERS:
+const float Branches = 1.0;
+const float scale = 0.4;
+const float off = 0.6;
+//Complex Math:
+vec2 complexExp(in vec2 z){
+  return vec2(exp(z.x)*cos(z.y),exp(z.x)*sin(z.y));
+}
+vec2 complexLog(in vec2 z){
+  return vec2(log(length(z)), atan(z.y, z.x));
+}
+vec2 complexMult(in vec2 a,in vec2 b){
+  return vec2(a.x*b.x - a.y*b.y, a.x*b.y + a.y*b.x);
+}
+float complexMag(in vec2 z){
+  return float(pow(length(z), 2.0));
+}
+vec2 complexReciprocal(in vec2 z){
+  return vec2(z.x / complexMag(z), -z.y / complexMag(z));
+}
+vec2 complexDiv(in vec2 a,in vec2 b){
+  return complexMult(a, complexReciprocal(b));
+}
+vec2 complexPower(in vec2 a, in vec2 b){
+  return complexExp( complexMult(b,complexLog(a))  );
+}
+//Misc Functions:
+float nearestPower(in float a, in float base){
+  return pow(base,  ceil(  log(abs(a))/log(base)  )-1.0 );
+}
+float map(float value, float istart, float istop, float ostart, float ostop) {
+     return ostart + (ostop - ostart) * ((value - istart) / (istop - istart));
+}
+
+void main( void ){
+
+  //SHIFT AND SCALE COORDINATES
+  vec2 uv=gl_FragCoord.xy/sketchSize.xy - off;
+
+  //ESCHER GRID TRANSFORM:
+  float factor = pow(1.0/scale,Branches);
+  uv= complexPower(uv, complexDiv(vec2( log(factor) ,TWO_PI), vec2(0.0,TWO_PI) ) );
+
+  //RECTANGULAR DROSTE EFFECT:
+  float FT = fract(globalTime);
+  FT = log(FT+1.)/log(2.);
+  uv *= 1.0+FT*(scale-1.0);
+
+  float npower = max(nearestPower(uv.x,scale),nearestPower(uv.y,scale));
+  uv.x = map(uv.x,-npower,npower,-1.0,1.0);
+  uv.y = map(uv.y,-npower,npower,-1.0,1.0);
+
+  //UNDO SHIFT AND SCALE:
+  gl_FragColor =  texture2D(texture,uv*off+vec2(off));
+}

library/video/capture/data/launch1.mp4

@@ -0,0 +1,81 @@
+// Original shader by RavenWorks
+// Fake Floyd-Steinberg dithering
+// https://www.shadertoy.com/view/4sjGRD
+
+// Adapted for PiCrate by Martin Prout <@monkstoneT>
+
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+#define PROCESSING_TEXTURE_SHADER
+
+uniform sampler2D texture; // iChannel0 in Shadertoy
+uniform vec2 sketchSize; // iResolution in Shadertoy
+
+const int lookupSize = 64;
+const float errorCarry = 0.3;
+
+float getGrayscale(vec2 coords){
+  vec2 uv = coords / sketchSize.xy;
+  // processing is already using inverted y coordinates
+  //  uv.y = 1.0-uv.y; 
+  vec3 sourcePixel = texture2D(texture, uv).rgb;
+  return length(sourcePixel*vec3(0.2126,0.7152,0.0722));
+}
+
+// in regular glsl was
+// void mainImage( out vec4 fragColor, in vec2 fragCoord )
+
+void main() {
+  
+  int topGapY = int(sketchSize.y - gl_FragCoord.y);
+  
+  int cornerGapX = int((gl_FragCoord.x < 10.0) ? gl_FragCoord.x : sketchSize.x - gl_FragCoord.x);
+  int cornerGapY = int((gl_FragCoord.y < 10.0) ? sketchSize.y : gl_FragCoord.y - gl_FragCoord.y);
+  int cornerThreshhold = ((cornerGapX == 0) || (topGapY == 0)) ? 5 : 4;
+  
+  if (cornerGapX+cornerGapY < cornerThreshhold) {
+        
+    gl_FragColor = vec4(0,0,0,1);
+    
+  } else if (topGapY < 20) {
+      
+      if (topGapY == 19) {
+        
+        gl_FragColor = vec4(0,0,0,1);
+        
+      } else {
+    
+        gl_FragColor = vec4(1,1,1,1);
+        
+      }
+    
+  } else {
+    
+    float xError = 0.0;
+    for(int xLook=0; xLook<lookupSize; xLook++){
+      float grayscale = getGrayscale(gl_FragCoord.xy + vec2(-lookupSize+xLook,0));
+      grayscale += xError;
+      float bit = grayscale >= 0.5 ? 1.0 : 0.0;
+      xError = (grayscale - bit)*errorCarry;
+    }
+    
+    float yError = 0.0;
+    for(int yLook=0; yLook<lookupSize; yLook++){
+      float grayscale = getGrayscale(gl_FragCoord.xy + vec2(0,-lookupSize+yLook));
+      grayscale += yError;
+      float bit = grayscale >= 0.5 ? 1.0 : 0.0;
+      yError = (grayscale - bit)*errorCarry;
+    }
+    
+    float finalGrayscale = getGrayscale(gl_FragCoord.xy);
+    finalGrayscale += xError*0.5 + yError*0.5;
+    float finalBit = finalGrayscale >= 0.5 ? 1.0 : 0.0;
+    
+    gl_FragColor = vec4(finalBit,finalBit,finalBit,1);
+      
+  }
+  
+}

library/video/capture/data/launch2.mp4

@@ -0,0 +1,43 @@
+require 'picrate'
+
+# hold down mouse to see unfiltered output
+class Droste < Processing::App
+  load_library :video
+  java_import 'processing.video.Capture'
+  attr_reader :cam, :my_filter, :origin
+
+  def settings
+    size(960, 720, P2D)
+  end
+
+  def setup
+    sketch_title 'Droste'
+    @origin = Time.now
+    @my_filter = load_shader(data_path('droste.glsl'))
+    my_filter.set('sketchSize', width.to_f, height.to_f)
+    start_capture
+  end
+
+  def time
+    (Time.now - origin) * 0.5
+  end
+
+  def start_capture
+    @cam = Capture.new(self, 960, 720, 'UVC Camera (046d:0825)')
+    cam.start
+  end
+
+  def draw
+    return unless cam.available
+    
+    background 0
+    cam.read
+    set(0, 0, cam)
+    my_filter.set('globalTime', time)
+    return if mouse_pressed?
+     
+    filter(my_filter)
+  end
+end
+
+Droste.new

library/video/capture/data/steinberg.glsl

@@ -0,0 +1,38 @@
+require 'picrate'
+# From an original shader by RavenWorks
+# hold down mouse to see unfiltered output
+class Steinberg < Processing::App
+  load_library :video
+  java_import 'processing.video.Capture'
+  attr_reader :cam, :my_shader
+
+  def settings
+    size(640, 480, P2D)
+  end
+
+  def setup
+    sketch_title 'Steinberg'
+    @my_shader = load_shader(data_path('steinberg.glsl'))
+    my_shader.set('sketchSize', width.to_f, height.to_f)
+    start_capture(width, height)
+  end
+
+  def start_capture(w, h)
+    @cam = Capture.new(self, width, height, 'UVC Camera (046d:0825)')
+    cam.start
+  end
+
+  def draw
+    return unless cam.available
+    
+    background 0
+    cam.read
+    set(0, 0, cam)
+    # image(cam, 0, 0, width, height)
+    return if mouse_pressed?
+    
+    filter(my_shader)
+  end
+end
+
+Steinberg.new

library/video/capture/droste.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+# placeholder for vector coordinates
+Vect = Struct.new(:x, :y)
+
+# A class to contain frame corners, uses forwardable
+class Corners
+  include Enumerable
+  extend Forwardable
+  def_delegators :@corners, :each_with_index, :[], :[]=, :<<
+  attr_reader :idx
+
+  def initialize(width, height, ws, wh)
+    @corners = [
+      Vect.new(width / 2 - ws, height / 2 - wh),
+      Vect.new(width / 2 + ws, height / 2 - wh),
+      Vect.new(width / 2 + ws, height / 2 + wh),
+      Vect.new(width / 2 - ws, height / 2 + wh)
+    ]
+    @idx = -1
+  end
+
+  def change_selected(mx, my)
+    self[idx] = Vect.new(mx, my)
+  end
+
+  def selected?
+    idx != -1
+  end
+
+  def select_corner(sel)
+    @idx = sel
+  end
+end

library/video/capture/steinberg.rb

@@ -1,8 +1,10 @@
 #!/usr/bin/env jruby -w
+# frozen_string_literal: true
+
 require 'picrate'
 # Loop.
 #
-# Shows how to load and play a QuickTime movie file.
+# Shows how to load and play a movie file.
 class Loop < Processing::App
   load_libraries :video
   include_package 'processing.video'
@@ -19,6 +21,7 @@ def setup
 
   def draw
     return unless movie.available
+
     movie.read
     image(movie, 0, 0, width, height)
   end