# It draws some orbs around the hole.

## Generative art with a large number of lines.

It's a generative art made with Processing programming code.
It draws circled orbs around the hole with a large number of lines. It derived from Big Bang.

I might not need the PshapeElement class to draw this at all. But I wanted to use an abstract class that I studied recently.
The PshapeElement is a brush of this code. I use line() as a brush this time. Changing brush like rect(), ellipse(), etc. will make different looks.

## The 'Processing' code example.

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

```// Hole In My Soul
// Processing 3.2.1
// 2017.08.19

import java.util.Random;

/* ---------------------------------------------------------------------- */
class Utils {

Random obj_random;

Utils() {
obj_random = new Random();
}

float gaussdist(float pmean, float plimit, float pdevi) {
/**
Gaussian distribution
1.parameters.
pmean  : mean value
plimit : max value of abs(deviation)
ex. plimit >= 0
pmean = 0.5, plimit = 0.5 -> return value = from 0.0 to 1.0
pdevi  : standard deviation value
ex. good value? -> pdevi = plimit / 2
2.return.
gaussian distribution
**/

if (plimit == 0) {
return pmean;
}

float gauss = (float) obj_random.nextGaussian() * pdevi;
// not good idea
if (abs(gauss) > plimit) {
gauss = pow(plimit, 2) / gauss;
}

return pmean + gauss;

}
}

/* ---------------------------------------------------------------------- */
abstract class PshapeElement {

PShape anElement;
float elementColor, elementSaturation, elementBright, elementAlpha;

PshapeElement() {
anElement = pscreateElement();
elementColor = 0;
elementSaturation = 0;
elementBright = 0;
elementAlpha = 0;
}

abstract PShape pscreateElement();

void setElementFill(float pcolor, float psaturation, float pbright, float palpha) {
elementColor = pcolor;
elementSaturation = psaturation;
elementBright = pbright;
elementAlpha = palpha;
resetColor();
}

void resetColor() {
anElement.setStroke(color(elementColor, elementSaturation, elementBright, elementAlpha));
}

void changeColor(float scolor) {
elementColor = scolor;
resetColor();
}

void changeBright(float sbright) {
elementBright = sbright;
resetColor();
}

void resetSize() {
anElement.resetMatrix();
}

void changeSize(float scaleX, float scaleY) {
anElement.scale(scaleX, scaleY);
}

void rotate(float radX) {
}

void show() {
shape(anElement);
}

}

/* ---------------------------------------------------------------------- */
class Brush extends PshapeElement {

Brush() {
super();
}

PShape pscreateElement() {

noFill();
strokeWeight(0.000001);
PShape psDp = createShape(LINE, 0.0, 0.0, 0.0, 0.1);
return psDp;

}

}

/* ---------------------------------------------------------------------- */
Utils ut;
PshapeElement brush;

void setup() {
size(900, 900);
colorMode(HSB, 360, 100, 100, 100);
blendMode(SCREEN);
smooth(8);
noLoop();
//  frameRate(1);

ut = new Utils();
brush = new Brush();

}

void draw() {

background(0, 0, 0);
translate(width / 2, height / 2);

drawEye();

saveFrame("frames/####.png");
exit();

}

void canvasRotation(float degrees, float fluctuation) {

translate(random(fluctuation), random(fluctuation));

}

void drawEye() {

int divCntMin = 1;
int divCntMax = 8;
int drawCntMax = 360;
float idxDiv = 3;

float baseColor = random(360.0);
float drawStart = abs(ut.gaussdist(10.0, 3.0, 2.0));
float baseDrawEnd = drawStart + abs(ut.gaussdist(80.0, 10.0, 5.0));

float noiseHueStart = random(100.0);
float noiseSatStart = random(100.0);
float noiseBriStart = random(100.0);
float noiseRotStart = random(100.0);

float sinMult = abs(ut.gaussdist(0.0, 1.0, 0.7));
float cosMult = sinMult * round(ut.gaussdist(0.0, 4.0, 2.0));

float noiseHue = noiseHueStart;

for (int divCnt = divCntMin; divCnt <= divCntMax; ++divCnt) {

float noiseRot = noiseRotStart;
float sumRotation = 0;

// Shift whole shape
canvasRotation(ut.gaussdist(2.0, 1.0, 0.5), 0.0);

for (int drawCnt = 0; drawCnt < drawCntMax; ++drawCnt) {

float rotation = map(noise(noiseRot), 0.0, 1.0, 0.5, 1.5);
canvasRotation(rotation, rotation / 2.0);
noiseRot += 0.05;
sumRotation += rotation;

float brushHue = (baseColor + 360 + map(noise(noiseHue), 0.0, 1.0, -60.0, 60)) % 360;
noiseHue += 0.02;

float noiseSat = noiseSatStart;
float noiseBri = noiseBriStart;
float drawEnd = baseDrawEnd * abs(sin(radians((sumRotation) * sinMult)) + cos(radians((sumRotation) * cosMult)));

for (float idxW = drawStart; idxW < drawEnd; ++idxW) {
for (float idxH = drawStart; idxH < drawEnd; ++idxH) {

float brushSat = map(noise(noiseSat), 0.0, 1.0, 40.0, 100.0);
float brushSiz = map(noise(noiseBri), 0.0, 1.0, 0.0, 30.0);
float brushBri = map(noise(noiseBri), 0.0, 1.0, 0.0, 50.0);
float brushAlp = map(noise(noiseBri), 0.0, 1.0, 0.0, 60.0);
noiseSat += 0.003;
noiseBri += 0.001;

pushMatrix();
translate(idxW * idxDiv, idxH * idxDiv);
brush.resetSize();
brush.changeSize(brushSiz, brushSiz);
brush.setElementFill(brushHue, brushSat, brushBri, brushAlp);
brush.show();
popMatrix();

}
}
}

canvasRotation(-sumRotation, 0.0);

}
}

/*
Copyright (C) 2017- deconbatch

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
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 <http://www.gnu.org/licenses/>
*/

```

No Comment