# Finding the 'Cat formula' during my pursuit of creative coding truth

## How I discovered the 'Cat formula' in this creative coding.

It's a creative coding animation work made with the 'Processing'.

I found a 'Cat formula' when I was palying with the idea of @ozachou_g.

How to Build Discrete Universe
https://how-to-build-du-e.tumblr.com/

A cat formula.

X1 = (pow(sin(X0), 3) + cos(Y0)) * sin(T0);
Y1 = (cos(X0) + pow(sin(Y0), 3)) * cos(T0);
T1 = T0 + timeDiv

And I made an animation with this morphing (lerping) method.

A, B  : morph from A shape to B shape
morph : from 1.0 to 0.0
shape = A * morph + B * (1 - morph)

## The 'Processing' code example.

Please feel free to use this code under the terms of the GPL.
To see other works based on my code is my pleasure. And my honor.

```// Morph the Cat.
// @author @deconbatch
// @version 0.1
// Processing 3.2.1
// 2018.11.11

void setup() {

size(720, 720);
colorMode(HSB, 360, 100, 100, 100);
blendMode(SUBTRACT);
smooth();
noLoop();
noStroke();

}

void draw() {

int   frameCntMax   = 15 * 6;  // 15fps x 6s
int   recurseCntMax = 2500;
float divRotate     = random(0.01, 0.02) * rndSign();
float baseHue       = random(360);

// cat shape
int   phaseCntMax  = 500;  // must for cat!  > 500
float phaseDiv     = 1.0 / phaseCntMax;
float phaseDivInit = PI * 0.75 - phaseDiv * phaseCntMax;

// some shape
float paramSomX = random(0.1, 1.0);
float paramSomY = random(0.1, 1.0) * rndSign();
float paramSomT = random(0.5, 1.5);

translate(width / 2, height / 2);
rotate(PI * (0.25 - 0.49 * frameCntMax * divRotate));  // for upright cat

for (int frameCnt = 1; frameCnt <= frameCntMax; ++frameCnt) {

float easing  = easeInOutCubic(map(frameCnt, 0, frameCntMax, 1.0, 0.0));  // animate factor
float timeDiv = phaseDivInit;

background((baseHue + 150) % 360, 5, 90, 100);
rotate(PI * divRotate * easing);

for (int phaseCnt = 0; phaseCnt < phaseCntMax; ++phaseCnt) {

float phaseRate = map(phaseCnt, 0, phaseCntMax, 0.0, 1.0);
timeDiv += PI * phaseDiv;

float prevCatX = 0.0;
float prevCatY = 0.0;
float prevCatT = 0.0;
float prevSomT = 0.0;

for (int recurseCnt = 0; recurseCnt < recurseCntMax; ++recurseCnt) {

// cat formula
float catX = (pow(sin(prevCatX), 3) + cos(prevCatY)) * sin(prevCatT);
float catY = (cos(prevCatX) + pow(sin(prevCatY), 3)) * cos(prevCatT);

// some shape formula
float somX = (sin(prevCatX) * paramSomX - cos(prevCatY) * paramSomY) + cos(prevSomT);
float somY = (cos(prevCatX) * paramSomX - sin(prevCatY) * paramSomY) + sin(prevSomT);

float x = catX * (1.0 - easing) + somX * easing;
float y = catY * (1.0 - easing) + somY * easing;

float catT = prevCatT + timeDiv;
float somT = prevSomT - (x + y) * paramSomT;

float eX = x * width * (0.35 + easing * 0.0);
float eY = y * height * (0.35 + easing * 0.0);
float eS = phaseRate;

fill(
(baseHue + phaseRate * 60.0) % 360,
40,
(1.0 - phaseRate) * 30.0,
100
);
ellipse(
eX,
eY,
eS,
eS
);

prevCatX = catX;
prevCatY = catY;
prevCatT = catT;
prevSomT = somT;

}
}

saveFrame("frames/" + String.format("%02d", frameCnt) + "00.png");

}

// for showing cat shape longer
for (int i = 0; i < 5; ++i) {
saveFrame("frames/99" + String.format("%02d", i) + ".png");
}

exit();

}

/**
* easeInOutCubic easing function.
* @param  t     0.0 - 1.0 : linear value.
* @return float 0.0 - 1.0 : eased value.
*/
private float easeInOutCubic(float t) {
t *= 2.0;
if (t < 1.0) {
return pow(t, 3) / 2.0;
}
t -= 2.0;
return (pow(t, 3) + 2.0) / 2.0;
}

/**
* rndSign random sign maker.
* @return int  +1 or -1 : random
*/
private int rndSign() {
int rndVal = ceil(random(-10, 10));
if (rndVal == 0) {
return -1;
} else {
return rndVal / abs(rndVal);
}
}

/*

This program is free software: you can redistribute it and/or modify
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see "https://www.gnu.org/licences/"
*/

```

No Comment