Random plaatjes generen totdat je fotos krijgt #2

<html>
<title></title>

<canvas id="view" width="250", height="250">
Canvas
</canvas>

<body bgcolor = "#FFFFFF">
</body>

<script type="text/javascript">

// Made by firefly3

var counter = 0;

element = document.getElementById("view");
c = element.getContext("2d");

width = element.width;
height = element.height;

imageData = c.createImageData(width, height);

var red = new Array(width);
var green = new Array(width);
var blue = new Array(width);

var redOld = new Array(width);
var greenOld = new Array(width);
var blueOld = new Array(width);

var amountofwaves = 18; //23 24 14 20

var lengthwaveA = new Array(amountofwaves);
var lengthwaveB = new Array(amountofwaves);
var lengthwaveC = new Array(amountofwaves);
var lengthwaveD = new Array(amountofwaves);

var phaseshiftwaveA = new Array(amountofwaves);
var phaseshiftwaveB = new Array(amountofwaves);
var phaseshiftwaveC = new Array(amountofwaves);
var phaseshiftwaveD = new Array(amountofwaves);

var lengthwaveA2 = new Array(amountofwaves);
var lengthwaveB2 = new Array(amountofwaves);
var lengthwaveC2 = new Array(amountofwaves);
var lengthwaveD2 = new Array(amountofwaves);

var phaseshiftwaveA2 = new Array(amountofwaves);
var phaseshiftwaveB2 = new Array(amountofwaves);
var phaseshiftwaveC2 = new Array(amountofwaves);
var phaseshiftwaveD2 = new Array(amountofwaves);

var wavelengthmax = 780.0
var wavelengthlowest = 380.0;

var spectrumrange = wavelengthmax - wavelengthlowest;

var amountoflightbeams = 10;

var wavelightfrequencies = new Array(amountofwaves);

var wavelightstrength = new Array(amountofwaves);

var historyred = new Array(width);
var historygreen = new Array(width);
var historyblue = new Array(width);

for(f = 0; f < amountofwaves; f++)
{

wavelightfrequencies[f] = new Array(amountoflightbeams);

}

for (i = 0; i < width; i++)
{
red[i] = new Array(height);
green[i] = new Array(height);
blue[i] = new Array(height);

redOld[i] = new Array(height);
greenOld[i] = new Array(height);
blueOld[i] = new Array(height);

historyred[i] = new Array(height);
historygreen[i] = new Array(height);
historyblue[i] = new Array(height);

for (j = 0; j < height; j++)
{
red[i][j] = 0;
green[i][j] = 0;
blue[i][j] = 0;

redOld[i][j] = 0;
greenOld[i][j] = 0;
blueOld[i][j] = 0;

historyred[i][j] = 0;
historygreen[i][j] = 0;
historyblue[i][j] = 0;

}
}

function setPixel(imageData, x, y, r, g, b, a)
{
index = (x + y * imageData.width) * 4;
imageData.data[index+0] = r;
imageData.data[index+1] = g;
imageData.data[index+2] = b;
imageData.data[index+3] = a;
}

function reset()
{

counter = 0;

for (xc = 0; xc < width; xc++)
{
for (yc = 0; yc < height; yc++)
{

historyred[xc][yc] = red[xc][yc];
historygreen[xc][yc] = green[xc][yc];
historyblue[xc][yc] = blue[xc][yc];

red[xc][yc] = 0;
green[xc][yc] = 0;
blue[xc][yc] = 0;

}
}
}

function history()
{

for (x = 0; x < width; x++)
{
for(y= 0; y< height; y++)
{

setPixel(imageData, y, x, historyred[x][y],historygreen[x][y],historyblue[x][y], 255);

}
}

c.putImageData(imageData, 0, 0);
}

function diff(num1, num2){
return (num1 > num2)? num1-num2 : num2-num1
}

function record()
{

}

function play()
{

}
function loop()
{
if(counter == 0)
{

lengthadj = 1.0;

scale = 800;//1200;//3900;//2400 1900 2500;

scale2 = scale / 4;

for (wavesInit = 0; wavesInit < amountofwaves; wavesInit++)
{

lengthwaveA[wavesInit] = (((Math.random()*20)+1) / scale) * lengthadj;
lengthwaveB[wavesInit] = (((Math.random()*20)+1) / scale) * lengthadj;
lengthwaveC[wavesInit] = (((Math.random()*20)+1) / scale) * lengthadj;
lengthwaveD[wavesInit] = (((Math.random()*20)+1) / scale) * lengthadj;

lengthadj *= 1.1; // 1.2
randadj = (Math.random()*10);
lengthadj *= 1 + (randadj/100.0);

phaseshiftwaveA[wavesInit] = ((Math.random() * 10) / 10) * (Math.PI*2.0);
phaseshiftwaveB[wavesInit] = ((Math.random() * 10) / 10) * (Math.PI*2.0);
phaseshiftwaveC[wavesInit] = ((Math.random() * 10) / 10) * (Math.PI*2.0);
phaseshiftwaveD[wavesInit] = ((Math.random() * 10) / 10) * (Math.PI*2.0);

lengthwaveA2[wavesInit] = (((Math.random()*20)+1) / scale) * lengthadj;
lengthwaveB2[wavesInit] = (((Math.random()*20)+1) / scale) * lengthadj;
lengthwaveC2[wavesInit] = (((Math.random()*20)+1) / scale) * lengthadj;
lengthwaveD2[wavesInit] = (((Math.random()*20)+1) / scale) * lengthadj;

phaseshiftwaveA2[wavesInit] = ((Math.random() * 10) / 10) * (Math.PI*2.0);
phaseshiftwaveB2[wavesInit] = ((Math.random() * 10) / 10) * (Math.PI*2.0);
phaseshiftwaveC2[wavesInit] = ((Math.random() * 10) / 10) * (Math.PI*2.0);
phaseshiftwaveD2[wavesInit] = ((Math.random() * 10) / 10) * (Math.PI*2.0);

//spectrumrange = wavelengthmax - wavelengthlowest;
wavelightstrength[wavesInit] = 0;

for(f = 0; f < amountoflightbeams; f++)
{
wavelightfrequencies[wavesInit][f] = wavelengthlowest + (Math.random()*400);
}

}

// Colorrange check

heighestredimage = 0;
heighestgreenimage = 0;
heighestblueimage = 0;
lowestredimage = 0;
lowestgreenimage = 0;
lowestblueimage = 0;

for (x = 0; x < width; x++)
{

for(y = 0; y< height; y++)
{

amount = 1.0;
amountold = amount;
amounttotal = 0;

amount2 = 1.0;
amountold2 = amount2;

amountR = 1.0;
amountoldR = amount;
amountG = 1.0;
amountoldG = amount;
amountB = 1.0;
amountoldB = amount;

for (wave = 0; wave < amountofwaves; wave++) // 25 20 // 30
{

amountA = Math.sin(phaseshiftwaveA[wave]+(x*lengthwaveA[wave]));
amountB = Math.sin(phaseshiftwaveB[wave]+(y*lengthwaveB[wave]));
amountC = Math.sin(phaseshiftwaveC[wave]+(x*lengthwaveC[wave]));
amountD = Math.sin(phaseshiftwaveD[wave]+(y*lengthwaveD[wave]));

amountE = Math.sin(phaseshiftwaveA2[wave]+(x*lengthwaveA2[wave]));
amountF = Math.sin(phaseshiftwaveB2[wave]+(y*lengthwaveB2[wave]));
amountG = Math.sin(phaseshiftwaveC2[wave]+(x*lengthwaveC2[wave]));
amountH = Math.sin(phaseshiftwaveD2[wave]+(y*lengthwaveD2[wave]));

// If 1 was the max, multiplying would decrease the wave. Now max is 2.
amountABCD = (amountA * amountB) + (amountC * amountD);

amountEFGH = (amountE * amountF) + (amountG * amountH) + (amountE * amountG);

amount2 = amountold2;

// multiply previous layer with new layer

amount = amountold * amountABCD;// + (0.5*amountEFGH*amountold);

amount2 = amountEFGH;

wavelightstrength[wave] = amount;

amountold = amount;
amounttotal += amount;

amountold2 = amount2;

}

for(wavesl = 0; wavesl < amountofwaves; wavesl++)
{
for(f = 0; f < amountoflightbeams; f++)
{

spectrumvalue = wavelightfrequencies[wavesl][f];

redvalue = 0;
greenvalue = 0;
bluevalue = 0;

if ((spectrumvalue >= 380.0) && (spectrumvalue < 440.0))
{
redvalue = -(spectrumvalue - 440.0) / (440.0 - 350.0);
greenvalue = 0.0;
bluevalue = 1.0;
}

if ((spectrumvalue >= 440.0) && (spectrumvalue < 490.0))
{
redvalue = 0.0;
greenvalue = (spectrumvalue - 440.0) / (490.0 - 440.0);
bluevalue = 1.0;
}
else
if ((spectrumvalue >= 490.0) && (spectrumvalue < 510.0))
{
redvalue = 0.0;
greenvalue = 1.0;
bluevalue = (-(spectrumvalue - 510.0)) / (510.0 - 490.0);
}
else
if ((spectrumvalue >= 510.0) && (spectrumvalue < 580.0))
{
redvalue = (spectrumvalue - 510.0) / (580.0 - 510.0);
greenvalue = 1.0;
bluevalue = 0.0;
}
else
if ((spectrumvalue >= 580.0) && (spectrumvalue < 645.0))
{
redvalue = 1.0;
greenvalue = (-(spectrumvalue - 645.0)) / (645.0 - 580.0);
bluevalue = 0.0;
}
else
if ((spectrumvalue >= 645.0) && (spectrumvalue <= 780.0))
{
redvalue = 1.0;
greenvalue = 0.0;
bluevalue = 0.0;
}
else
{
redvalue = 0.0;
greenvalue = 0.0;
bluevalue = 0.0;
}

colorintensity = 0;

if ((spectrumvalue >= 380.0) && (spectrumvalue < 420.0))
{
colorintensity = 0.3 + 0.7 * (spectrumvalue - 350) / (420.0 - 350.0);
}
else
if ((spectrumvalue >= 420.0) && (spectrumvalue < 700.0))
{
colorintensity = 1.0;
}
else
if ((spectrumvalue > 700.0) && (spectrumvalue < 780.0))
{
colorintensity = 0.3 + 0.7 * (780.0 - spectrumvalue) / (780.0 - 700.0);
}
else
{
colorintensity = 0.0;
}

colorintensity *= wavelightstrength[wavesl];

redvalue *= colorintensity;
greenvalue *= colorintensity;
bluevalue *= colorintensity;

red[x][y] += redvalue;

green[x][y] += greenvalue;

blue[x][y] += bluevalue;

}

// colorrange check

if (heighestredimage < red[x][y])
{
heighestredimage = red[x][y];
}
if (heighestgreenimage < green[x][y])
{
heighestgreenimage = green[x][y];
}
if (heighestblueimage < blue[x][y])
{
heighestblueimage = blue[x][y];
}
if (lowestredimage > red[x][y])
{
lowestredimage = red[x][y];
}
if (lowestgreenimage > green[x][y])
{
lowestgreenimage = green[x][y];
}
if (lowestblueimage > blue[x][y])
{
lowestblueimage = blue[x][y];

}

}
}
}

// Normalize and render
for (x = 0; x < width; x++)
{
for(y = 0; y < height; y++)
{

redrange = heighestredimage - lowestredimage;
greenrange = heighestgreenimage - lowestgreenimage;
bluerange = heighestblueimage - lowestblueimage;

redstep = 255.0 / redrange;
greenstep = 255.0 / greenrange;
bluestep = 255.0 / bluerange;

rednormalized = (red[x][y] - lowestredimage) * redstep;
greennormalized = (green[x][y] - lowestgreenimage) * greenstep;
bluenormalized = (blue[x][y] - lowestblueimage) * bluestep;

red[x][y] = rednormalized;
green[x][y] = greennormalized;
blue[x][y] = bluenormalized;

setPixel(imageData, y, x, red[x][y],green[x][y],blue[x][y], 255);

redOld[x][y] = red[x][y];
greenOld[x][y] = green[x][y];
blueOld[x][y] = blue[x][y];
}
}

}

else
{

}

document.onkeypress = function (e)
{
e = e || window.event;
var charCode = e.charCode || e.keyCode,
character = String.fromCharCode(charCode);

if(character == 'a')
{
reset();
}
}

c.putImageData(imageData, 0, 0);

counter++;

setTimeout("loop()",0); // 100
}

loop();

</script>
<br>
<button onclick="reset()">New</button>
<button onclick="history()">History</button>
<button onclick="record()">Record</button>
<button onclick="play()">Play</button>

<br>
<br>

</html>