Snippet Zone

Catmull Rom to Bezier SVG

```
// from: 
```

//   https://github.com/DmitryBaranovskiy/raphael/blob/b5fdbdc9850827eb49622cd0bc81b26025f8128a/dev/raphael.core.js#L1019

```
// and: 
```

//   http://schepers.cc/getting-to-the-point

```
 
```

function catmullRom2bezier(crp, close) {

```
  const d = [];
```

  for (let i = 0, iLen = crp.length; iLen - 2 * !close > i; i += 2) {

```
    const p = [
```
```
      { x: crp[i - 2], y: crp[i - 1] },
```
```
      { x: crp[i], y: crp[i + 1] },
```
```
      { x: crp[i + 2], y: crp[i + 3] },
```
```
      { x: crp[i + 4], y: crp[i + 5] }
```
```
    ];
```
```
    if (close) {
```
```
      if (!i) {
```

        p[0] = { x: crp[iLen - 2], y: crp[iLen - 1] };

```
      } else if (iLen - 4 == i) {
```

        p[3] = { x: crp[0], y: crp[1] };

```
      } else if (iLen - 2 == i) {
```

        p[2] = { x: crp[0], y: crp[1] };

        p[3] = { x: crp[2], y: crp[3] };

```
      }
```
```
    } else {
```
```
      if (iLen - 4 == i) {
```
```
        p[3] = p[2];
```
```
      } else if (!i) {
```

        p[0] = { x: crp[i], y: crp[i + 1] };

```
      }
```
```
    }
```
```
    d.push([
```
```
      'C',
```

      (-p[0].x + 6 * p[1].x + p[2].x) / 6,

      (-p[0].y + 6 * p[1].y + p[2].y) / 6,

      (p[1].x + 6 * p[2].x - p[3].x) / 6,

      (p[1].y + 6 * p[2].y - p[3].y) / 6,

```
      p[2].x,
```
```
      p[2].y
```
```
    ]);
```
```
  }
```
```
 
```
```
  // really for demo purposes:
```
```
 
```

  // draw a tiny rect if less than 2 points

```
  console.log(d.length);
```
```
  if (d.length < 2) {
```
```
    const x = crp[0];
```
```
    const y = crp[1];
```

    return `M ${x} ${y} h 1 v 1 h -1 v-1`;

```
 
```
```
    // draw a line if 2 points
```
```
  } else if (d.length === 2) {
```

    return `M ${crp[0]} ${crp[1]} L ` + crp.flat().join` `;

```
  }
```

  // draw curves if 3 or more (raphael only ever did this, other numbers of points

```
  // were considered invalid)
```

  return  `M ${crp[0]} ${crp[1]}` + d.flat().join` `;

```
}
```
```
 
```
```
// try it out:
```
```
 
```

const pathCommands = catmullRom2bezier([

  100, 100, 200, 100, 200, 300, 170, 150, 120, 180, 120, 120

```
  ], true)
```
```
 
```
```
const svg = `
```
```
  click 3 or more times anywhere<br>
```
```
  <button>clear</button>
```
```
  <svg>
```

    <path d="M 100 100 ${pathCommands}" stroke="blue" fill="none" />

```
  </svg>
```
```
  <style>
```
```
  svg {
```
```
    position:absolute;
```
```
    left:0;top:0;
```
```
    overflow:visible;
```
```
    pointer-events:none;
```
```
  }
```
```
  </style>
```
```
`;
```
```
 
```
```
const div = document.body.appendChild(
```
```
  document.createElement('div')
```
```
);
```
```
div.innerHTML = svg;
```
```
const path = div.querySelector('path')
```
```
 
```
```
let pnts = [];
```
```
 
```
```
function isButton(e) {
```
```
  if (e.target.tagName === 'BUTTON') {
```
```
    pnts = []
```

    path.setAttribute('d', 'M 0 0L0 0');

```
    return true;
```
```
  }
```
```
}
```
```
 
```

document.addEventListener('click', e => {

```
  if (isButton(e)) return;
```
```
  pnts.push(e.clientX, e.clientY);
```

  path.setAttribute('d', catmullRom2bezier(pnts, true))

```
});
```
```
 
```

document.addEventListener('touchend', e => {

```
  if (isButton(e)) return;
```

  pnts.push(e.touchs[0].clientX, e.touchs[0].e.clientY);

  path.setAttribute('d', catmullRom2bezier(pnts, true))

```
});
```

Raphaël was my first deep dive into SVG. Back then, only VML was supported in older IE versions, so using Raphaël was key for tons of commercial work I did (Raphaël generated VML as well as SVG). This snippet is the Catmull Rom code from Raphaël. I’m pretty sure I didn’t know what a Catmull Rom spline was until I found out that using `R` in a path wasn’t supported natively in SVG… and was actually some magic thing that existed in Raphaël alone.

October 1, 2021

// curves // javascript // math // svg

John Wallis Pi (Wallis Product)

```
/*
```

It was always my affectation even from a child, in all pieces

of Learning or Knowledge, not merely to learn by rote, which

is soon forgotten, but to know the grounds or reasons of what

I learn; to inform my Judgement, as well as furnish my Memory;

and thereby, make a better Impression on both.

```
 
```
```
- John Wallis
```
```
 
```
```
*/
```
```
 
```
```
i = c = 1
```
```
setInterval(_ => {
```
```
  for (j = 0; j < 1000; j++, i += .5)
```

    c *= (~~i * 2) / (~~(i - .5) * 2 + 1)

```
 
```

  console.log(c * 2 + '\n' + 3.141592653589793)

```
}, 16);
```

π = 2

2 / 1

2 / 3

4 / 3

4 / 5

6 / 5

6 / 7

8 / 7

8 / 9

· · · ·

I was at an old book store a few days ago and randomly picked up History of Mathematics Vol. I by David Eugene Smith 1923 for $7.50. After enjoying flipping around and reading different parts, I pulled up Wikipedia to read more about the author… From there I found some interesting quotes from talking about John Wallis – when I saw the Wallis Product I was inspired to write a quick snippet.

September 30, 2021

// golfed // javascript // math // pi

ASCII Circles (Bresenham Fun)

```
// some circles made of text
```
```
 
```
```
const cols = 50;
```
```
const rows = 50;
```
```
const sym = '.';
```
```
const body = document.body;
```
```
 
```
```
Object.assign(body.style, {
```
```
  userSelect: 'none',
```
```
  fontFamily: 'Courier, monospace',
```
```
  position: 'fixed', 
```
```
  width: '100%',
```
```
  height: '100%',
```
```
  margin: 0
```
```
});
```
```
 
```
```
const el = body.appendChild(
```
```
  document.createElement('span')
```
```
);
```
```
el.innerHTML = sym;
```
```
 
```
```
Object.assign(el.style, {
```
```
  position: 'absolute',
```
```
  left: '50%',
```
```
  top: '50%',
```
```
  wordWrap: 'break-word',
```
```
  cursor: 'pointer'
```
```
});
```
```
 
```

const charSize = el.getBoundingClientRect().width;

```
const elWidth = charSize * cols;
```
```
el.style.display = 'block'
```
```
el.style.width = `${elWidth}px`;
```
```
 
```
```
const info = body.appendChild(
```
```
  document.createElement('div')
```
```
);
```
```
 
```
```
Object.assign(info.style, {
```
```
  background: '#fff',
```
```
  padding: '4px',
```
```
  position: 'absolute'
```
```
})
```

info.innerHTML = 'click/tap and hold for different fx';

```
 
```
```
function resize() {
```
```
  const scl = Math.min(
```
```
    1.23, 
```

    Math.min(innerWidth, innerHeight) / elWidth * .93

```
  );
```

  el.style.transform = `translate(-50%, -50%) scale(${scl}, ${scl * .55})`

```
}
```
```
addEventListener('resize', resize);
```
```
resize();
```
```
 
```
```
const size = cols * rows;
```
```
const pix = sym.repeat(size);
```
```
el.innerHTML = pix;
```
```
 
```
```
let cells = pix.split('')
```
```
const blank = cells.concat();
```
```
 
```
```
function setSym(x, y, col) {
```
```
  const idx = x + y * cols;
```
```
  if (cells[idx] != null) {
```
```
    cells[idx] = col;
```
```
  }
```
```
  return setSym
```
```
}
```
```
 
```
```
const grad = '::;|0UU888NN';
```
```
function circ(shooter) {
```

  let x = Math.round(Math.random() * cols);

  let y = Math.round(Math.random() * rows);

```
  const rad = Math.round(
```
```
    shooter ? Math.random() * 2 :
```

      Math.random() * Math.random() * 13 + 1

```
  );
```
```
 
```

  const sym = shooter ? '#' : grad.charAt(rad % grad.length);

```
  let speed = rad / 10 + .1;
```
```
  let dir = Math.random() * 2 - 1;
```
```
  return () => {
```

    drawCircle(x, y, rad, sym, shooter);

```
    y += speed;
```
```
    if (shooter) x += speed * 3 * dir;
```
```
    if (y > rows + 10) y = -14;
```
```
  }
```
```
}
```
```
 
```
```
const circs = [];
```
```
const NUM = 40;
```
```
for (let i = 0; i < NUM; i++) {
```
```
  circs.push(circ(Math.random() > 0.5))
```
```
}
```
```
 
```
```
let down;
```

document.addEventListener('mousedown', () => {

```
  down = true;
```
```
});
```

document.addEventListener('mouseup', () => {

```
  down = false;
```
```
});
```

document.addEventListener('touchstart', () => {

```
  down = true;
```
```
});
```

document.addEventListener('touchend', () => {

```
  down = false;
```
```
});
```
```
 
```
```
let tweak;
```
```
let tweakChoice;
```
```
let tweakChance = 0.4;
```

const clear = () => cells = blank.concat();

```
 
```
```
function draw() {
```
```
  if (!down) {
```
```
    tweak = false;
```
```
    tweakChoice = Math.random();
```
```
    clear();
```
```
  } else {
```
```
    if (tweakChoice < tweakChance) {
```
```
      tweak = true;
```
```
      clear();
```
```
    }
```
```
  }
```
```
 
```
```
  circs.forEach(circ => circ());
```
```
  el.innerHTML = cells.join('');
```
```
}
```
```
 
```

// 60fps is too fast, so use 30ms interval

```
setInterval(draw, 30);
```
```
 
```
```
function hLine(xp, yp, w, col) {
```
```
  for (let i = 0; i < w; i++) {
```
```
    setSym(xp + i, yp, col);
```
```
  }
```
```
  return hLine;
```
```
}
```
```
 
```
```
// bresenham circle
```

function drawCircle(xp, yp, radius, sym = '@', isFilled) {

```
  if (isFilled && tweak) sym = '';
```
```
 
```
```
  xp = parseInt(xp, 10);
```
```
  yp = parseInt(yp, 10);
```
```
  radius = parseInt(radius, 10);
```
```
  let balance = -radius,
```
```
    xoff = 0,
```
```
    yoff = radius;
```
```
 
```
```
  while (xoff <= yoff) {
```
```
    const p0 = xp - xoff;
```
```
    const p1 = xp + xoff;
```
```
 
```
```
    const p2 = yp + yoff;
```
```
    const p3 = yp - yoff;
```
```
    const p4 = yp + xoff;
```
```
    const p5 = xp + yoff;
```
```
    const p6 = xp - yoff;
```
```
    const p7 = yp - xoff;
```
```
 
```
```
    if (isFilled) {
```
```
      const w0 = xoff + xoff;
```
```
      const w1 = yoff + yoff;
```
```
 
```
```
      hLine
```
```
        (p0, yp + yoff, w0, sym)
```
```
        (p0, yp - yoff, w0, sym)
```
```
        (p6, yp + xoff, w1, sym)
```
```
        (p6, yp - xoff, w1, sym);
```
```
 
```
```
    } else {
```
```
      setSym
```
```
        (p1, p2, sym)
```
```
        (p0, p2, sym)
```
```
        (p0, p3, sym)
```
```
        (p1, p3, sym)
```
```
        (p5, p4, sym)
```
```
        (p6, p4, sym)
```
```
        (p6, p7, sym)
```
```
        (p5, p7, sym);
```
```
    }
```
```
 
```

    // never been able to find the original

```
    // source for the below condition 
```

    // more info here: https://actionsnippet.com/?p=492

    if ((balance += xoff++ + xoff) >= 0) {

```
      balance -= --yoff + yoff;
```
```
    }
```
```
  }
```
```
}
```

This is a bit of a longer snippet that uses the Bresenham circle drawing algorithm to draw some circles with text. I recommend looking at it with the fullscreen button.

I like to do this:

```
hLine
```
```
  (p0, yp + yoff, w0, sym)
```
```
  (p0, yp - yoff, w0, sym)
```
```
  (p6, yp + xoff, w1, sym)
```
```
  (p6, yp - xoff, w1, sym);
```

Make a function return itself, so that if you need to call it many times without having to repeat the function name. Because this isn’t a common style it is generally frowned upon, I’m always tempted to use it at work for some reason… maybe next April fools.

September 26, 2021

// animation // arrays // graphics // hacks // humor // javascript // math // random // strings // tricks

30% Chance Math.random()

```
// 30%
```
```
if (Math.random() < .3) {
```
```
  // 30% chance this will run
```
```
  console.log('30%');
```
```
} else {
```
```
  console.log('nope');
```
```
}
```

I do this all the time when creative coding. I usually use a seeded random number generator instead of Math.random. It’s very useful to have something happen X% of the time.

Let’s run this a few times and look at the results. Click/tap try it out.

```
for (let i = 0; i < 111; i++) {
```
```
  if (Math.random() < .3) {
```
```
    console.log('30%');
```
```
  } else {
```
```
    console.log('nope');
```
```
  }
```
```
}
```

Scroll through the results of the console window.

September 25, 2021

// javascript // math // random // tricks

Cistercian Numerals (semi-golfed)

```
N = -1
```
```
S = 30
```
```
H = 90
```
```
h = 45
```
```
d = document
```
```
b = d.body
```
```
m = _ => d.createElement(_)
```
```
a = _ => b.appendChild(_)
```
```
 
```
```
with(a(
```
```
    Object.assign(
```
```
      m`canvas`,
```
```
      { width: 80, height: 120 }
```
```
    )
```
```
  ).getContext`2d`
```
```
) { 
```
```
  a(m`br`)
```
```
 
```
```
  L = (a, b, C, d) => {
```
```
    moveTo(a, b)
```
```
    lineTo(C, d)
```
```
  }
```
```
 
```
```
  M = _ => L(0, 0, 0, H)
```
```
  O = _ => L(0, 0, S, 0)
```
```
  W = _ => L(0, S, S, S)
```
```
  T = _ => L(0, 0, S, S)
```
```
  F = _ => L(0, S, S, 0)
```
```
  X = _ => L(S, 0, S, S)
```
```
 
```
```
  D = [
```
```
    _ => {},
```
```
    O, W, T, F, 
```
```
    [O,F],
```
```
    X,
```
```
    [O,X],
```
```
    [W,X],
```
```
    [O,W,X]
```
```
  ]
```
```
 
```
```
  n = s => {
```
```
    [...s].reverse().map((l, i) => {
```
```
      save()
```
```
      translate(S+9, h+9)
```
```
      scale(N**i, N**~~(i/2))
```
```
      translate(0, -h)
```

      M() ;[D[l]].flat().map(x => x && x())

```
      restore()
```
```
    })
```
```
  }
```
```
 
```
```
  a(m`input`).oninput = e => {
```
```
    clearRect(0, 0, 80, 120)
```
```
    beginPath()
```
```
    n(~~e.target.value+'')
```
```
    stroke()
```
```
  }
```
```
}
```

Type any number from 0-9999 into the input field and see the corresponding Cistercian Numeral. This snippet is partially golfed, I left the canvas commands intact to make things a bit easier to understand.

Simpler SVG Version

This one hardcodes all numbers 0-9 as paths, unlike the canvas version which only defines 1,2,3,4 and 6 as paths and then combines them to create 5,7,8 and 9.

```
h='innerHTML'
```
```
C='children'
```
```
 
```
```
document.body[h]=`
```

<svg id=G width=99 viewBox="0 0 80 120"

  style="stroke:black;fill:none;overflow:visible">

```
  <g transform="translate(30,2)">
```
```
    <path d="M0 0L 30 0"/>
```
```
    <path d="M0 30L 30 30"/>
```
```
    <path d="M0 0L 30 30"/>
```
```
    <path d="M0 30L30 0"/>
```
```
    <path d="M0 30L30 0 0 0"/>
```
```
    <path d="M30 0L30 30"/>
```
```
    <path d="M30 30L30 0 0 0"/>
```
```
    <path d="M0 30L30 30 30 0"/>
```
```
    <path d="M0 30L30 30 30 0 0 0"/>
```
```
  </g>
```

  <g transform=translate(30,2)scale(-1,1)></g>

  <g transform=translate(30,92)scale(1,-1)></g>

  <g transform=translate(30,92)scale(-1,-1)></g>

```
  <path id=m d="M 30 2 L 30 92"/>
```
```
</svg>
```

<style>path:not(#m){opacity:0}</style><br>

```
<input id=I>`
```
```
 
```
```
c=G[C]
```
```
p=c[0][h] 
```
```
 
```
```
n = s => 
```
```
  [...s].reverse().map((l, i) => 
```

   l-1>-1 && (c[i][C][l-1].style.opacity=1))

```
 
```
```
I.oninput = e => {
```
```
  for(i=0;i<4;i++)c[i][h]=p
```
```
  n(~~e.target.value+'')
```
```
}
```

September 24, 2021

// arrays // canvas // codegolf // graphics // hacks // javascript // math

Older Posts

Newer Posts