# Category Archives: graphics algorithms

## Pathtracer Research

I spent awhile a few months ago learning about Pathtracers… After I good deal of research I ended up forking Evan Wallace’s Path Tracer and added a few new features and shapes - some of which I learned from Erich Loftis’s Three.js PathTracing Renderer.

view demo 1 view demo 2 Been wanting to get back to this and do optimizations and boolean shapes - but so far I haven’t gotten around to it.

## Zeta Pictograms

I have a set of ~100 pictograms that I use for personal notation. When I was actively working on Zeta. I created a few of these with equations:

I spam my facebook with images from my sketchbooks if you’re at all interested in seeing more pictograms: In 2015 I created QuickShader… which just takes the boilerplate out of showing a shader in the browser. Here are a few examples:

Also posted in Graphics, Math, color, glsl, html5, javascript, motion, pixel manipulation | Tagged , | Leave a comment

Being able to draw smooth lines that connect arbitrary points is something that I find myself needing very frequently. This is a port of an old snippet that does just that. By averaging control points of a quadratic bezier curve we ensure that our resulting Bezier curves are always smooth.

The key can be seen here with the `bezierSkin` function. It draws either a closed or open curve.

```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 // array of xy coords, closed boolean function bezierSkin(bez, closed = true) { var avg = calcAvgs(bez), leng = bez.length, i, n;   if (closed) { c.moveTo(avg, avg); for (i = 2; i < leng; i += 2) { n = i + 1; c.quadraticCurveTo(bez[i], bez[n], avg[i], avg[n]); } c.quadraticCurveTo(bez, bez, avg, avg); } else { c.moveTo(bez, bez); c.lineTo(avg, avg); for (i = 2; i < leng - 2; i += 2) { n = i + 1; c.quadraticCurveTo(bez[i], bez[n], avg[i], avg[n]); } c.lineTo(bez[leng - 2], bez[leng - 1]); } }     // create anchor points by averaging the control points function calcAvgs(p) { var avg = [], leng = p.length, prev; for (var i = 2; i < leng; i++) { prev = i - 2; avg.push((p[prev] + p[i]) / 2); } // close avg.push((p + p[leng - 2]) / 2); avg.push((p + p[leng - 1]) / 2); return avg; }```

The control points are then averaged to ensure that the curve contains no sharp angles.

Also posted in Graphics, Math, arrays, bezier, html5, javascript | Tagged , , , , | Leave a comment

Awhile back I thought it would be interesting to add some quick fake lighting to a personal project of mine - that for lack of a better description is a windows management system.

Here is a screenshot of the windows management system with lighting turned on: Here is a video of me using the system:

I whipped up this prototype (don’t mind the jQuery)

There are really two keys that make this work. Getting the shadow in place and adjusting the gradient. All we really need is the angle and distance from a given `div` in relation to the “light”:

```1 2 3 4 5 6 7 8 9 10 11 12 13 let calcAng = function(x, y) { let lightPos = light.position() let dx = lightPos.left - x; let dy = lightPos.top - y; return -Math.atan2(dy, dx) / Math.PI * 180; };   let calcDist = function(x, y) { let lightPos = light.position() let dx = lightPos.left - x; let dy = lightPos.top - y; return Math.sqrt(dx * dx, dy * dy); };```

Standard `atan2` and the pythagorean theorem get us this. Once we have those - we can use them to set our gradient and shadow values:

```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 // warning (apparently this function is slightly speed coded) let calcShade = function(x, y) { let angle = calcAng(x, y); let dist = calcDist(x, y); let sx = dist * Math.cos(-angle * Math.PI / 180) * -1; let sy = dist * Math.sin(-angle * Math.PI / 180) * -1;   sx = Math.min(20, Math.max(sx, -20)); sy = Math.min(20, Math.max(sy, -20)); let blur = Math.min(100, dist); let hBlur = Math.min(50, blur) * 0.5; // consider distance in the eq? return { bg: `-webkit-linear-gradient(\${angle}deg, rgba(0, 0, 0, 0.2), rgba(255, 255, 255, 0.4) \${blur}%)`, shadow: `\${sx}px \${sy}px \${hBlur}px rgba(0, 0, 0, 0.15)` }; };```

There are more videos of the windows management system on my youtube channel. Here’s another from a much earlier version of the system.

Maybe I’ll post more about that in the future…

## 3d Point to 2d Point (Easy Mini 3d Engine)

Many years ago when I had just started programming I found this absolute gem by Andries Odendaal.

modern es6 version

```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 let rotX = 0, rotY = 0, perspective = 500, depth, currX, currY; // learned something like this at Andries Odendaal's www.wireframe.co.za function point3d(x, y, z) { let cosX = Math.cos(rotX), cosY = Math.cos(rotY), sinX = Math.sin(rotX), sinY = Math.sin(rotY), posX, posY, posZ;   posZ = z * cosX - x * sinX, posX = z * sinX + x * cosX, posY = y * cosY - posZ * sinY, posZ = y * sinY + posZ * cosY;   depth = 1 / (posZ / perspective + 1); currX = posX * depth; currY = posY * depth;   return [ currX, currY, depth ]; }```

Here’s is an example of it in action:

I’ve used this code many many times, it’s just easy to throw into any language and instantly get 3d points rendered in 2d. Here is a short video of a Java applet from 2003 called “Catch Env” that made use of it:

Here is the source code for that ^^
http://www.zevanrosser.com/shape2/j/Catchenv.java

You’ll notice in that source, that I nested the equation to allow for local and global transformations. It was around that time that I learned the ins and outs of real 2D and 3D matrix transformation math… Ken Perlin’s classfiles from NYU were a real help when I was learning that stuff. I don’t think this was the exact file I was working with, but it was definitely on his site somewhere.

Before all that, during my junior year in college I created a 3d engine based off Odendaal’s code in Director (Lingo). Here is a video of some of the demos for it:

…and here is a strange screenshot from my personal website at the time: Just an example of a powerful snippet and a gateway to learning matrix transformation math. When I first really dug in to html5 canvas - before WebGL was supported so widely - having this trick up my sleeve was great. As you can see in the below link, I used it more than a few times back then:

Daily canvas experiments:

http://zreference.com/projects/all-graphics.php ## Hermit Crab Curve as PRNG # (a deterministic pseudo-random number generator with contrast and smoothness - inspired by stochastic and organic randomness)

Around 2015 I had the idea for a PRNG that would clamp itself and have moments of “smoothness”. When I got around to trying to create such a thing, the result was something I jokingly called the “Hermit Crab Curve”. I also called it the “Shard Curve”.

The equation for the curve defines a radius in polar coordinates: Where a and d are paramters that control the detail of the curve. o is a rotation and offset value for the angle and s is a scalar. Note the use of rem. The resulting curve is much less interesting if a standard modulo is used in place of a remainder: The above variable values were found using this interactive version of the equation:

To illustrate how you might use this as a PRNG I created this fork of the above pen:

That, in combination with the information from my other article from yesterday… Should be enough to see what I mean. You can read the original description of the Hermit Crab Curve that I created using ArcType here:

If you end up using this for something interesting let me know. I’d love to see it Also posted in Graphics, Math, functions, javascript, misc, motion | Tagged , , | Leave a comment

## Gumowski/Mira Pseudo-Soundwave

Actionscript:
1. [SWF(width = 600, height = 600)]
2. var a:Number = 0.02;
3. var b:Number = .9998;
4.
5. var xn1:Number = 5;
6. var yn1:Number = 0;
7. var xn:Number, yn:Number;
8.
9. var scale:Number = 10;
10. var iterations:Number = 20000;
11. var step:Number = stage.stageWidth / iterations;
12.
13. function f(x:Number):Number{
14.     var x2:Number = x * x;
15.     return a * x + (2 * (1 - a) * x2) / (1 + x2);
16. }
17.
18. var canvas:BitmapData = Bitmap(addChild(new Bitmap(new BitmapData(600,600,false,0xEFEFEF)))).bitmapData;
19.
20. var circle = new Sprite();
21. with(circle.graphics) beginFill(0, 0.3), drawCircle(2,2,1);
22.
23. var dot:BitmapData = new BitmapData(4,4,true, 0x00000000);
24. dot.draw(circle);
25.
26. var pnt:Point = new Point();
27.
28. var txt:TextField = TextField(addChild(new TextField()));
29. txt.text = "move mouse";
30.
32. function onLoop(evt:Event):void {
33.
34.     canvas.fillRect(canvas.rect, 0xEFEFEF);
35.
36.     a = mouseY / 1000;
37.     xn1 = mouseX / 30;
38.     yn1 = 0;
39.     for (var i:int = 0; i<iterations; i++){
40.           xn = xn1;
41.           yn = yn1;
42.
43.           xn1 = b * yn + f(xn);
44.           yn1 =  -xn + f(xn1);
45.           pnt.x = i * step;
46.           pnt.y = 300 + yn1 * scale;
47.           canvas.copyPixels(dot, dot.rect, pnt, null, null, true);
48.
49.     }
50. }

Try it out:

Gumowski Mira Pseudo-soundwave - wonderfl build flash online

## Frame Differencing

Actionscript:
1. [SWF(width = 800, height= 600)]
2. var sw:Number = 800;
3. var sh:Number = 600;
4. var pixelNum:int = sw * sh;
5. var blurAmount:Number = 10;
6. var pnt:Point = new Point(0,0);
7. var rect:Rectangle = new Rectangle(0,0,sw,sh);
8.
9. var canvas:BitmapData = new BitmapData(sw, sh, false, 0x000000);
10. var buffer:BitmapData = new BitmapData(sw, sh, false, 0x000000);
11. var feed  :BitmapData = new BitmapData(sw, sh, false, 0x000000);
12. var prev  :BitmapData = new BitmapData(sw, sh, false, 0x000000);
13.
14. var frame:Bitmap = new Bitmap(canvas, "auto", true);
16.
17. var cam:Camera =  Camera.getCamera();
18. cam.setMode(sw,sh,12);
19. var video:Video = new Video(sw, sh);
20. video.attachCamera(cam);
21.
23.
24. function onActivityStart(evt:ActivityEvent):void {
26.     cam.removeEventListener(ActivityEvent.ACTIVITY, onActivityStart);
27. }
28.
29. function onRun(evt:Event):void{
30.     buffer.draw(video);
31.     feed.copyPixels(buffer, rect, pnt);
32.     buffer.draw(prev, null, null, BlendMode.DIFFERENCE);
33.     prev.draw(video);
34.     canvas.copyPixels(buffer, rect, pnt);
35. }

This snippet shows a simple method to do frame differencing with a web cam. This is useful for detecting which areas of the screen have change from frame to frame. This post assumes you pretty much know what frame differencing is.

You can view an swf file here: This is one of those things I do a good deal but never wrapped up into a library... it's easy (for me at least) to forget exactly how to set it up from scratch.

I added an extra buffer because it's pretty common that you'll want to other things aside from just frame differencing alone, so it's nice to have it all wrapped up in a buffer BitmapData that you can use elsewhere. If speed is a real concern, you can do away with the buffer and just use the canvas instead - depending on what kind of analysis your doing on the frame differenced image it may be trickier without the buffer.

Also posted in BitmapData, Video, pixel manipulation | Tagged , , | 5 Comments

## ~20,000 Rollovers

Actionscript:
1. [SWF(width = 500, height = 500, frameRate = 30)]
2.
3. var canvas:BitmapData = new BitmapData(stage.stageWidth,stage.stageHeight,false, 0xFFFFFF);
4.
5. var indexCanvas:BitmapData = new BitmapData(stage.stage.stageWidth, stage.stageHeight, false,
6.                                             0xFFFFFF);
8.
9. var s:Shape = new Shape();
10.
11. var lineData:Array = [];
12. var dataIndex:int = 0;
13.
14. trace(0xFFFFFF - 1)
15. var totalLines:int = 20000;
16. var iterations:int = 9;
17. var linesPerIter:int = totalLines / iterations;
18.
19. var xp:int = stage.stageWidth / 2;
20. var yp:int = stage.stageHeight / 2;
21.
22. var stepAmt:Number = 60;
23. var halfStepAmt:Number = stepAmt / 2;
24.
26. function onDraw(evt:Event):void {
27.      if (lineData.length <totalLines){
28.         generateData(linesPerIter);
29.      }else{
30.         stage.quality = "high";
32.         s.x = 0;
33.         s.y = 0;
34.
35.         removeEventListener(Event.ENTER_FRAME, onDraw);
37.      }
38. }
39.
40. function onRun(evt:Event):void {
41.    var currentIndex:int = indexCanvas.getPixel(mouseX, mouseY);
42.    var currentLine:Array = lineData[currentIndex];
43.
44.    s.graphics.clear();
45.    if (currentIndex != 0xFFFFFF){
46.           s.graphics.lineStyle(3, 0xFF0000);
47.           s.graphics.moveTo(currentLine, currentLine);
48.           s.graphics.lineTo(currentLine, currentLine);
49.    }
50. }
51.
52. function generateData(num:int):void{
53.     var rxA:int, rxB:int, ryA:int, ryB:int;
54.     var g:Graphics = s.graphics;
55.     for (var i:int = 0; i<num; i++){
56.         rxA = xp;
57.         ryA = yp;
58.
59.         xp += Math.round(Math.random() * stepAmt) - halfStepAmt;
60.         yp += Math.round(Math.random() * stepAmt) - halfStepAmt;
61.
62.         if (xp> stage.stageWidth){
63.             xp = stage.stageWidth - halfStepAmt;
64.         }else
65.         if (xp <0){
66.             xp = halfStepAmt;
67.         }
68.         if (yp> stage.stageHeight){
69.             yp = stage.stageHeight - halfStepAmt;
70.         }else
71.         if (yp <0){
72.             yp = halfStepAmt;
73.         }
74.
75.         rxB = xp;
76.         ryB = yp;
77.
78.         lineData[dataIndex] = [rxA, ryA, rxB, ryB];
79.         s.x = rxA;
80.         s.y = ryA;
81.         var endX:Number = rxB - rxA;
82.         var endY:Number = ryB - ryA;
83.         var m:Matrix = s.transform.matrix;
84.         g.clear();
85.         g.lineStyle(1, 0x000000, 0.3);
86.
87.         g.lineTo(endX, endY);
88.         stage.quality = "high";
89.         canvas.draw(s, m);
90.
91.         g.clear();
92.         g.lineStyle(3, dataIndex);
93.
94.         g.lineTo(endX, endY);
95.         stage.quality = "low";
96.         indexCanvas.draw(s, m);
97.
98.         dataIndex++
99.     }
100. }

I'm working on a data visualization that contains a long path made up of approximately one million points. There is some information associated with every two sets of coordinates that needs to be displayed when the user rolls their mouse over any part of the line.

I took a little time to think about the best way to do this and came up with a few techniques. The first one I tried seems to work nicely - this snippet is the proof of concept for that first technique. I tested this snippet with 1,000,000 xy coordinates and it works nicely. It takes a little while to draw though, so for the purposes of this demo I've just included 20,000 coordinates.

Have a look at the swf over at wonderfl.net

The way this works is by drawing lines to two different BitmapData instances. I draw anti-aliased slightly transparent lines to a BitmapData instance called "canvas" (this is added to the display list) - I then draw aliased lines to a BitmapData called "indexCanvas" (this is never added to the display list) - each aliased line uses an incremental value for its color - this incremental value is also the index for a two dimensional array containing the coordinate information for the aliased line. I use getPixel() on the "indexCanvas" and use the return value as the index for the 2D array. The data from the 2D array is used to draw a red line with the graphics class. This technique enables you to have many many rollovers and all you ever have to do is call getPixel() and use the returned color value to look up info about what you're mouse is touching.

There are a few cool ways this could be repurposed and this is really only one solution to the problem of having many many things that you need to be able to rollover... there are others that don't use BitmapData at all... I may write those up in the next couple of days.

Also posted in BitmapData, Data Structures, UI, arrays, display list, matrix, misc, pixel manipulation, return values | Tagged , , | 2 Comments

• 